mirror of
https://github.com/pbakaus/impeccable.git
synced 2026-09-13 06:36:26 +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
54 lines
1.9 KiB
Rust
54 lines
1.9 KiB
Rust
//! impeccable-comp: the pure, browser-independent foundation of the
|
|
//! comp-fidelity pipeline, ported from the skill's JS libs.
|
|
//!
|
|
//! Ported modules (all pure, no browser, no CLI):
|
|
//! - `png_io` — JS lib/png.mjs (decode/encode + loadRaster)
|
|
//! - `raster` — JS lib/raster.mjs (image type and ops)
|
|
//! - `metrics` — JS lib/image-metrics.mjs (the comparison math)
|
|
//! - `font_fingerprint` — JS lib/font-fingerprint.mjs
|
|
//! - `font_index` — JS lib/font-index.mjs
|
|
//! - `hero` — JS lib/hero-checks.mjs (+ the pure `inkBox`)
|
|
//!
|
|
//! Deferred to step 2 (need a browser or the verb orchestrators): the
|
|
//! Playwright/CDP rendering behind font-match `renderCandidates`, and the four
|
|
//! orchestrators build-phase / comp-diff / comp-spec / font-match.
|
|
|
|
pub mod font_fingerprint;
|
|
pub mod font_index;
|
|
pub mod hero;
|
|
pub mod jsnum;
|
|
pub mod metrics;
|
|
pub mod png_io;
|
|
pub mod raster;
|
|
|
|
/// CRC-32 (IEEE, the same polynomial the JS png encoder uses) over a byte
|
|
/// slice. Exposed so parity tests can checksum decoded pixel buffers.
|
|
pub fn crc32(data: &[u8]) -> u32 {
|
|
static TABLE: once_cell::sync::Lazy<[u32; 256]> = once_cell::sync::Lazy::new(|| {
|
|
let mut t = [0u32; 256];
|
|
for (n, slot) in t.iter_mut().enumerate() {
|
|
let mut c = n as u32;
|
|
for _ in 0..8 {
|
|
c = if c & 1 != 0 { 0xedb8_8320 ^ (c >> 1) } else { c >> 1 };
|
|
}
|
|
*slot = c;
|
|
}
|
|
t
|
|
});
|
|
let mut c: u32 = 0xffff_ffff;
|
|
for &b in data {
|
|
c = TABLE[((c ^ b as u32) & 0xff) as usize] ^ (c >> 8);
|
|
}
|
|
c ^ 0xffff_ffff
|
|
}
|
|
|
|
/// CRC-32 over an f32 slice, matching the JS `crc32(new Uint8Array(f32.buffer))`
|
|
/// (little-endian byte layout, as on the recording host).
|
|
pub fn crc32_f32(data: &[f32]) -> u32 {
|
|
let mut bytes = Vec::with_capacity(data.len() * 4);
|
|
for &v in data {
|
|
bytes.extend_from_slice(&v.to_le_bytes());
|
|
}
|
|
crc32(&bytes)
|
|
}
|