mirror of
https://github.com/pbakaus/impeccable.git
synced 2026-09-12 22:26:38 +03:00
Paul BakausandClaude Fable 5.1
0547ed6a63
The engine no longer lives in a separate repo. `crates/` is a snapshot of the
open crates (foundation, core, common, context, live, hook, skills, comp,
comp-verbs, html, browser, detect, cli) plus `Cargo.lock`, taken as a git
archive of the engine repo at the commit that finished the boundary split.
None of that repo's history comes with it, and none of it should: the closed
half stays private.
The closed half is the rule engine. It ships as a prebuilt native archive per
target, `libimpeccable_detector.a`, published as a `detector-v<X>` GitHub
Release on this repo. `crates/core/build.rs` resolves and links it three ways:
`IMPECCABLE_DETECTOR_LIB=<dir>` for a local detector build, else the
`~/.impeccable/detector/<version>/<target>/` cache, else a download verified
against its `.sha256` sidecar. `crates/core` is a thin shim over a three-symbol
C ABI; nothing above it knows the boundary exists.
What changed versus the engine repo copy:
- Every crate manifest moves from `license-file.workspace` to
`license.workspace` (this workspace declares Apache-2.0), and the workspace
gains the `postcard` dependency the boundary encoding needs.
- The launcher contract test reads `skill/scripts/impeccable{,.cmd}` instead of
a sibling `launcher/` dir, and `engine_binary` downloads from
`github.com/pbakaus/impeccable/releases/download/engine-v<version>/` instead
of the retired dist repo. No oracle golden carried the old URL, so no
re-recording was owed.
- The tests that hunted for a public repo through `IMPECCABLE_PUBLIC_REPO`,
`../impeccable-second` or a hardcoded home directory now resolve the root as
`CARGO_MANIFEST_DIR/../..`, because they are in it. The env var stays as an
override for an out-of-tree checkout.
- The in-page bundle (`detect-antipatterns-browser.js`, 2 MB of generated wasm
glue) is no longer tracked. `crates/core/build.rs` resolves it beside the
archive, hands the path to `impeccable_core::browser::IN_PAGE_BUNDLE_JS`, and
live mode serves that. `scripts/check-detector-release.mjs` now requires it
and its `.sha256` in a detector release.
- The live crate embeds `skill/scripts/live-browser*.js` and
`modern-screenshot.umd.js` directly rather than through vendored copies, so
the binary and the installed skill cannot drift.
- `crates/browser/assets/` (an unused second copy of the bundle) is gone.
- `tests/lib/engine-bin.mjs` also accepts `target/release/impeccable`, so a
plain `cargo build --release -p impeccable` is enough to run `bun run test`.
Verified with the archive from a local detector build: `cargo test --workspace`
267 pass, oracle 795 pass / 0 fail / 0 missing, `bun run build` clean, the
default suite green, and the launcher's `engine-probe` handshake answering
through `skill/scripts/impeccable`.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vau2X53xGTjjTCXWMVBoNY
76 lines
2.9 KiB
Rust
76 lines
2.9 KiB
Rust
//! `collectStaticCssRules` and `unwrapCssAtLayer` have no recorded call
|
|
//! vectors, so their expected output was produced by running the JS
|
|
//! (`css-cascade.mjs` + css-tree 3.2.1) in Node over a corpus of synthetic
|
|
//! stylesheets (nested @media / @supports / @layer, :hover shapes, comma
|
|
//! selectors, !important, custom properties, malformed CSS, comments,
|
|
//! @import / @font-face / @keyframes, unicode, escapes) plus every `<style>`
|
|
//! block and .css file under the public repo's tests/, skill/ and cli/.
|
|
//! Regenerate `fixtures/css-rules.json` with
|
|
//! `node crates/html/tests/fixtures/gen-css-rules.mjs`.
|
|
|
|
use impeccable_html::cascade::rules::{collect_static_css_rules, CssRule};
|
|
use impeccable_html::cascade::values::unwrap_css_at_layer;
|
|
use serde_json::Value;
|
|
|
|
fn rules_to_json(rules: &[CssRule]) -> Value {
|
|
Value::Array(
|
|
rules
|
|
.iter()
|
|
.map(|r| {
|
|
serde_json::json!({
|
|
"selector": r.selector,
|
|
"declarations": r.declarations.iter().map(|d| serde_json::json!({
|
|
"prop": d.prop, "value": d.value, "important": d.important,
|
|
})).collect::<Vec<_>>(),
|
|
"specificity": r.specificity,
|
|
"order": r.order,
|
|
"isHover": r.is_hover,
|
|
"matchSelector": r.match_selector,
|
|
})
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn collect_static_css_rules_matches_node() {
|
|
let text = include_str!("fixtures/css-rules.json");
|
|
let cases: Vec<Value> = serde_json::from_str(text).unwrap();
|
|
let mut failures: Vec<String> = Vec::new();
|
|
let mut checked = 0usize;
|
|
for case in &cases {
|
|
let css = case["css"].as_str().unwrap();
|
|
let name = case["name"].as_str().unwrap();
|
|
let expected = &case["rules"];
|
|
let actual = rules_to_json(&collect_static_css_rules(css));
|
|
checked += 1;
|
|
if &actual != expected {
|
|
// Find the first differing rule for a readable report.
|
|
let ea = expected.as_array().unwrap();
|
|
let aa = actual.as_array().unwrap();
|
|
let mut detail = format!("expected {} rules, got {}", ea.len(), aa.len());
|
|
for (i, (e, a)) in ea.iter().zip(aa.iter()).enumerate() {
|
|
if e != a {
|
|
detail = format!("rule {}:\n expected {}\n actual {}", i, e, a);
|
|
break;
|
|
}
|
|
}
|
|
failures.push(format!("[{}] css={:?}\n {}", name, css, detail));
|
|
}
|
|
let unwrapped = unwrap_css_at_layer(css);
|
|
if Some(unwrapped.as_str()) != case["unwrapped"].as_str() {
|
|
failures.push(format!(
|
|
"[{}] unwrapCssAtLayer mismatch for css={:?}",
|
|
name, css
|
|
));
|
|
}
|
|
}
|
|
assert!(
|
|
failures.is_empty(),
|
|
"{} of {} cases differ:\n{}",
|
|
failures.len(),
|
|
checked,
|
|
failures.join("\n")
|
|
);
|
|
}
|