@amsterdamdatalabs/adl-agent-control-linux-x64 0.1.12 → 0.1.28

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/check.py

@@ -37,44 +37,61 @@ check.sh's comparison used the literal garbled string, that same clean-pass
 case would report a finding instead of passing. The restored string is the
 only one consistent with test.sh's own asserted outcome.
 
-**Two deviations this port does NOT resolve, only documents**, because
-`compliance_py`'s architecture makes check.sh's literal design unstatable
-here rather than merely inconvenient:
-
-1. **No git object reads (K-41).** check.sh deliberately reads the path from
-   the index (`:path`, pre-commit) or `HEAD` (`HEAD:path`, elsewhere) via
-   `git cat-file`, and its own comment explains why at length: the WORKTREE
-   file is not a safe source, because a correctly-tracked LFS pointer is
-   smudged back to full content on disk, and a check reading the worktree
-   would flag the very files that are doing the right thing. check.sh calls
-   this risk "latent, not hypothetical" for the shell tree's OWN prior
-   design, which read the worktree and was replaced because of it.
-
-   `compliance_py` has exactly one file that calls `git` or resolves a root
-   — `cli.py` — and every check, this one included, is handed a `Context`
-   and a `FileSet` with no way to reach a git object store (see
-   `core/check.py`'s docstring and `INVARIANTS.md`'s K-41 entry, verified
-   there as `git: 1 module`). There is no established mechanism in this
-   package for a check to read `:path`/`HEAD:path` instead of the worktree
-   file, and none is added here. `graded` below reads the WORKTREE file
-   `ctx.path(rel)` resolves to, which means it inherits the exact risk
-   check.sh's comment names — a large file whose LFS pointer HAS been
-   smudged back to full content by an active `git-lfs` filter would be
-   misreported as a violation. check.sh's own measurement on the checkout it
-   was written against found no case of this actually happening (one sampled
-   LFS-tracked file was the same byte count in the worktree as in `HEAD`),
-   so the risk carries over as documented rather than as an active defect —
-   but it is a real, named gap, not a silent one, and resolving it needs
-   either a git-object-reading mechanism added to this package's
-   architecture or an accepted exception for this one gate.
-
-2. **No phase (K-43).** check.sh branches its object read on
-   `ADL_GATE_PHASE` (index at pre-commit, `HEAD` everywhere else).
-   `compliance_py` reads no phase anywhere — "nothing reads a phase" is
-   K-43, and K-33 records phase-conditional behaviour as retired by
-   construction. There is one behaviour here, not two: `graded` grades
-   whatever the caller's `FileSet` contains, exactly like every other check
-   in this package.
+**What is graded where (K-41 stays true: the CLI supplies the facts).**
+check.sh reads the path from the index (`:path`, pre-commit) or `HEAD`
+(`HEAD:path`, elsewhere) via `git cat-file`, and its own comment explains why at
+length: the WORKTREE file is not a safe source, because a correctly-tracked LFS
+file is a pointer in Git and is smudged back to full content on disk, so a check
+reading the worktree flags the very files that are doing the right thing.
+check.sh called that risk "latent, not hypothetical". It was measured on
+2026-10-01 against enact-combined: `live-probes/local/chat-local/output/
+evidence/probe-result-video.webm` has `git check-attr filter` = lfs, a committed
+blob of 132 bytes (`git cat-file -s :path`) and a 1,170,147-byte worktree file,
+and the worktree-reading version of this check reported it as a violation. No
+change inside that repository can clear it: the path is tracked correctly.
+
+This check still performs no git reads. `compliance_py` has exactly one file that
+calls `git` -- `cli.py` (K-41; measured 2026-10-01: it is the only non-test
+module under `src/adl_compliance` that builds a git subprocess argv) -- and a
+check is handed a `Context` and a `FileSet` with no way to reach an object store. What
+changed is that the CLI now measures the fact and hands it down: this class sets
+`reads_committed_sizes`, and when a selected row does, `cli.committed_blob_sizes`
+runs two git processes however many paths there are (`ls-files --stage -z`, then
+ONE `cat-file --batch-check`) and `Context.committed_sizes` maps each tracked
+path to the size of the blob in the index. `graded` then grades:
+
+  * a path WITH a committed size, by that size alone, against `THRESHOLD`. A
+    committed pointer is ~132 bytes, so it is silent whatever the worktree
+    holds; a committed blob over the threshold is reported with the COMMITTED
+    size, whatever the worktree holds and whether or not the worktree file still
+    exists (an unstaged deletion leaves the blob stored). There is no pointer
+    comparison on this path: a real pointer is far under the threshold, so a
+    stored blob over it is not one, whatever its first line says.
+  * a path WITHOUT one, by its worktree file, exactly as this check always did,
+    pointer comparison included. A path has no committed size when it is
+    untracked or new, a gitlink, unmerged, in a root with no git repository, or
+    when the run is `--exhaustive` -- a snapshot whose bytes the caller vouches
+    ARE the candidate commit, for which `cli.py` does not ask whichever
+    repository might enclose it. A missing fact is never "small": a big file with
+    no committed size is still reported. The gap that remains is the mirror of
+    the one closed: a smudged LFS pointer at a path with no committed size would
+    still be misreported, and in a git repository that can only be a path not
+    yet in the index.
+
+"Stored" is the INDEX entry, not `HEAD`: for a clean checkout they are the same
+blob, and while staging it is the blob about to be committed -- check.sh's
+`:path`. An edit not yet staged is therefore not graded for a tracked path (a
+small committed file grown past the threshold in the worktree is reported once
+`git add` stores it, not before).
+
+**No phase (K-43).** check.sh branches its object read on
+`ADL_GATE_PHASE` (index at pre-commit, `HEAD` everywhere else).
+`compliance_py` reads no phase anywhere -- "nothing reads a phase" is
+K-43, and K-33 records phase-conditional behaviour as retired by
+construction. There is one behaviour here, not two: the facts come from the
+index in every run that has a git repository, and `graded` grades whatever
+the caller's `FileSet` contains, exactly like every other check in this
+package.
 
 `.gitattributes` matching is scoped to the repository-root file only, using
 "last matching pattern wins" (`core.scope.matches`, the same rule real
@@ -83,23 +100,123 @@ check.sh's `git check-attr` resolves the full multi-directory and global
 attribute stack; this does not, and every case `test.sh` exercises uses a
 single root-level file, so this is enough to prove the branch, not a claim
 of full `check-attr` parity.
+
+**The ratchet register (2026-10-01, Tarun: "add a ratchet", "ratchets go under
+compliance/ folder").** A repository that already carries blobs over the threshold
+records them in `<compliance>/ratchets/LFS-001-large-blobs.yaml` --
+`schema_version: 1` and `over_limit_baseline: {<repo-relative path>: <size in
+bytes>}` -- and the gate holds each at its recorded size. It is the repository's
+OWN debt, so it is a consumer input (`inputs`), never packaged data, the same
+reasoning as LAY-004's register. Three rules, all over the one question `_assess`
+answers for every path in the set and every entry in the register:
+
+  LFS-002  over the threshold with no entry (the finding this gate always had).
+  LFS-003  over its own recorded size; names both sizes.
+  LFS-004  an entry that is no longer required -- its file is not in the tree, is
+           at or under the threshold, or is stored as an LFS pointer -- so the
+           register can only shrink. Adding an entry declares new debt; the repair
+           for LFS-003 never offers to raise one.
+
+A register that EXISTS but cannot be used (invalid YAML, a repeated path, a size
+that is not a positive integer, an unknown key, a path that is not a normalised
+repository-relative one) is could-not-run, never ignored. `register` is a
+`widening_inputs` member: it only ever ADDS an allowance, so no file, an empty
+baseline, or a `compliance` tree declared absent (`""`) all mean "nothing is
+ratcheted" and grade exactly as before. KNOWN GAP, measured and not closed here:
+a `compliance` tree that is UNDECLARED (absent from the map, not `""`) is
+could-not-run, because `runner.resolve_inputs` expands every input before it
+reaches the widening branch; the message names what to declare. Before the register
+existed that case graded normally, and both repositories in this estate declare the
+tree.
+
+Selection has no gap: the row's scope is `**` (less fixtures), so a change to the
+register selects the gate with no `<compliance>` scope entry -- which would make
+the row could-not-run in a repository that declares no such tree.
+
+**Why LFS-004 is not gated on an exhaustive run.** LAY-004's DIR-003 grades
+absence from a set, so a narrower set inflates it, and the obvious guard is to fire
+only when the caller vouches the set is the whole tree. That fact is the runner's
+`exhaustive` argument and `Context` does not carry it, so a check cannot read it.
+This gate does not need to: it never infers staleness from a path being absent from
+the SET. `structural` probes each entry's own path with the same `_assess` the set's
+paths get, so a file the set simply does not name, but which is still over the
+threshold, is not stale (a test pins that for both values of `exhaustive`). The real
+pre-commit path always grades the whole staged snapshot with `--exhaustive`
+(`src/hook.ts`, `withStagedIndexSnapshot`), so a narrowed run exists only as a
+manual `--files`. What that leaves open: on such a run an entry for a TRACKED path
+the set does not name is judged from the worktree alone, since `committed_sizes`
+covers only the given paths, so an unstaged deletion or shrink of it reads as stale
+until it is staged. The mirror error is also possible there -- an entry kept alive by
+a smudged worktree copy of a file Git now stores as a pointer -- and only delays its
+removal. Neither lets a blob over the threshold through.
 """
 
 from __future__ import annotations
 
 from collections.abc import Iterable
 from pathlib import Path
-from typing import ClassVar
+from typing import Annotated, ClassVar, Literal
+
+import yaml
+from pydantic import Field, field_validator
 
 from ....core import scope
 from ....core.check import Check
 from ....core.context import Context, FileSet
+from ....core.errors import CouldNotRun, SchemaInvalid
 from ....core.finding import Report
+from ....core.models import StrictModel
+
+
+class Register(StrictModel):
+    """The repository's recorded debt: every blob it already carries over the
+    threshold, with the size it had when that was recorded."""
+
+    schema_version: Literal[1]
+    """Locked, not just typed: a future bump must change this literal, which makes
+    it a deliberate, schema-revealing edit rather than a silent one."""
+
+    over_limit_baseline: dict[str, Annotated[int, Field(gt=0)]]
+    """Repository-relative file path -> size in bytes. Required (an empty map is a
+    register with no debt, a missing key is a typo), and a size is a positive
+    integer: a string, float or boolean is refused, not coerced."""
+
+    @field_validator("over_limit_baseline")
+    @classmethod
+    def _paths_are_normalised(cls, value: dict[str, int]) -> dict[str, int]:
+        for path in value:
+            if "\\" in path or any(part in ("", ".", "..") for part in path.split("/")):
+                raise ValueError(f"{path!r} is not a normalised repository-relative file path")
+        return value
+
+
+class UniqueKeyLoader(yaml.SafeLoader):
+    """`yaml.safe_load`, except that a repeated mapping key is an error.
+
+    PyYAML keeps the LAST of a repeated key without a word. In a register that
+    only ever shrinks that is a silent drop: lowering an entry by adding a second
+    line, with the old higher one left in place, would be ignored."""
+
+    def construct_mapping(self, node: yaml.MappingNode, deep: bool = False) -> dict[object, object]:
+        seen: set[object] = set()
+        for key_node, _ in node.value:
+            key = self.construct_object(key_node, deep=True)
+            try:
+                if key in seen:
+                    raise yaml.constructor.ConstructorError(
+                        None, None, f"found a duplicate key {key!r}", key_node.start_mark
+                    )
+                seen.add(key)
+            except TypeError:
+                break  # unhashable: the base class refuses it below, with its own message
+        return super().construct_mapping(node, deep=deep)
 
 
 class Integrity(Check):
     id: ClassVar[str] = "LFS-001"
     rule: ClassVar[str] = "LFS-002"
+    GREW: ClassVar[str] = "LFS-003"
+    STALE: ClassVar[str] = "LFS-004"
 
     THRESHOLD: ClassVar[int] = 1024 * 1024
     """check.sh: `threshold=$((1024 * 1024))`. A blob strictly larger fails."""
@@ -112,34 +229,137 @@ class Integrity(Check):
     GITATTRIBUTES: ClassVar[str] = ".gitattributes"
     FILTER_LFS: ClassVar[str] = "filter=lfs"
 
+    reads_committed_sizes: ClassVar[bool] = True
+
+    # CONSUMER-OWNED: a ratchet baseline IS the repository's own recorded debt
+    # (see LAY-004's `register`), so it is read from the repository's declared
+    # `compliance` tree and never shipped. Optional on purpose -- see
+    # `widening_inputs`: an absent file, or a repository that declares no such
+    # tree, means nothing is ratcheted and every blob over the threshold is
+    # reported as before.
+    inputs: ClassVar[dict[str, str]] = {
+        "register": "<compliance>/ratchets/LFS-001-large-blobs.yaml",
+    }
+
+    # The register only ever ADDS an allowance, so leaving it out can only produce
+    # MORE findings, never fewer. Requiring the tree would push an owner into
+    # declaring a directory they may not have. Read with `.get()`, never assumed.
+    widening_inputs: ClassVar[frozenset[str]] = frozenset({"register"})
+
+    def structural(self, ctx: Context) -> Iterable[Report]:
+        # LFS-004 probes each ENTRY's own path, the same question `graded` asks of
+        # every path in the set, so it never reads absence from the set. An entry
+        # for a file the set simply does not name is not stale. See the module
+        # docstring, "Why LFS-004 is not gated on an exhaustive run".
+        for rel, _recorded in sorted(self._register(ctx).items()):
+            size, why = self._assess(ctx, rel)
+            if size is None:
+                yield self.report(
+                    rel,
+                    f"ratchet entry for {rel} is no longer required: {why}",
+                    f"delete {rel} from over_limit_baseline in {self._shown(ctx)}",
+                    rule=self.STALE,
+                )
+
     def graded(self, ctx: Context, files: FileSet) -> Iterable[Report]:
+        recorded = self._register(ctx)
         for rel in files:
-            target = ctx.path(rel)
-            if not target.is_file():
-                # check.sh: a path `cat-file --batch-check` answers `missing`
-                # for -- deleted from the index, or never tracked -- is not a
-                # blob entering the repository, so there is nothing to
-                # enforce (its own comment on the `blob` type test).
+            size, _why = self._assess(ctx, rel)
+            if size is None:
                 continue
+            allowed = recorded.get(rel)
+            if allowed is None:
+                yield self._violation(rel, size)
+            elif size > allowed:
+                yield self._grew(rel, size, allowed)
 
-            size = target.stat().st_size
-            if size <= self.THRESHOLD:
-                continue
+    def _assess(self, ctx: Context, rel: str) -> tuple[int | None, str]:
+        """`(size, "")` when `rel` is a blob entering Git over the threshold,
+        otherwise `(None, why not)`. The one question asked of every path in the
+        set and of every register entry, so the two can never disagree."""
+        stored = ctx.committed_sizes.get(rel)
+        if stored is not None:
+            # Git has a blob for this path, and its size is what enters the
+            # repository -- the worktree file is not (a smudged LFS file is
+            # the full content on disk and a ~132-byte pointer in Git). Graded
+            # whether or not the worktree file still exists: an unstaged
+            # deletion leaves the blob stored. No pointer comparison here: a
+            # real pointer is far under the threshold, so a stored blob over it
+            # is not one, whatever its first line says.
+            if stored > self.THRESHOLD:
+                return stored, ""
+            return None, (
+                f"Git stores {stored} bytes for it, at or under the {self.THRESHOLD}-byte threshold"
+            )
 
-            if self._tracked_by_lfs(ctx, rel) and self._first_line(target) == self.POINTER:
-                continue
+        target = ctx.path(rel)
+        if not target.is_file():
+            # check.sh: a path `cat-file --batch-check` answers `missing`
+            # for -- deleted from the index, or never tracked -- is not a
+            # blob entering the repository, so there is nothing to
+            # enforce (its own comment on the `blob` type test).
+            return None, "it is not a file in the tree"
 
-            # check.sh: both conditions are required, not either one -- a
-            # `.gitattributes` rule alone does not excuse content that was
-            # never actually converted to a pointer, and a pointer-shaped
-            # first line alone does not excuse a path with no rule tracking
-            # it. See "attribute-without-conversion" in this gate's fixtures.
-            yield self.report(
-                rel,
-                f"{rel} is a {size}-byte blob entering Git without the LFS filter",
-                f"add a .gitattributes rule matching {rel} to filter=lfs, run "
-                f"'git lfs track' for that pattern, then re-add {rel}",
-            )
+        size = target.stat().st_size
+        if size <= self.THRESHOLD:
+            return None, f"it is {size} bytes, at or under the {self.THRESHOLD}-byte threshold"
+
+        if self._tracked_by_lfs(ctx, rel) and self._first_line(target) == self.POINTER:
+            return None, "it is an LFS pointer under a matching .gitattributes rule"
+
+        # check.sh: both conditions are required, not either one -- a
+        # `.gitattributes` rule alone does not excuse content that was
+        # never actually converted to a pointer, and a pointer-shaped
+        # first line alone does not excuse a path with no rule tracking
+        # it. See "attribute-without-conversion" in this gate's fixtures.
+        return size, ""
+
+    def _violation(self, rel: str, size: int) -> Report:
+        return self.report(
+            rel,
+            f"{rel} is a {size}-byte blob entering Git without the LFS filter",
+            f"add a .gitattributes rule matching {rel} to filter=lfs, run "
+            f"'git lfs track' for that pattern, then re-add {rel}",
+        )
+
+    def _grew(self, rel: str, size: int, recorded: int) -> Report:
+        return self.report(
+            rel,
+            f"{rel} is a {size}-byte blob entering Git without the LFS filter, "
+            f"over its ratchet entry of {recorded} bytes",
+            f"shrink {rel} to at most {recorded} bytes, or move it to LFS (add a "
+            f".gitattributes rule matching {rel} to filter=lfs, run 'git lfs track' for "
+            f"that pattern, then re-add {rel}); the register only shrinks, so do not "
+            "raise its entry",
+            rule=self.GREW,
+        )
+
+    # ------------------------------------------------------------ the register
+
+    def _register(self, ctx: Context) -> dict[str, int]:
+        """The repository's recorded debt, or `{}` when it records none.
+
+        Absent (no file, or the input dropped because the tree is undeclared) is
+        `{}`: nothing is ratcheted, which grades STRICTER. A register that EXISTS
+        but cannot be used is could-not-run, never ignored -- ignoring it would
+        grade every ratcheted blob as fresh debt, or drop an allowance unseen."""
+        target = ctx.inputs.get("register")
+        if target is None or not target.exists():
+            return {}
+        shown = self._shown(ctx)
+        if not target.is_file():
+            raise CouldNotRun(f"LFS-001 ratchet register {shown} exists but is not a file")
+        body = self.text(ctx, target)
+        try:
+            loaded = yaml.load(body, Loader=UniqueKeyLoader)  # noqa: S506 - a SafeLoader
+            return dict(self._validate(loaded, Register, shown).over_limit_baseline)
+        except yaml.YAMLError as exc:
+            raise CouldNotRun(f"LFS-001 ratchet register {shown} is not valid YAML: {exc}") from exc
+        except SchemaInvalid as exc:
+            raise CouldNotRun(f"LFS-001 ratchet register is unusable: {exc.detail}") from exc
+
+    def _shown(self, ctx: Context) -> str:
+        return ctx.relative(ctx.inputs["register"])
 
     # ------------------------------------------------------------- reading
 

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/absolute-path.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "/a.png": 2000000

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/backslash-path.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "a\\b.png": 2000000

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/baseline-is-a-list.yaml

@@ -0,0 +1,2 @@
+schema_version: 1
+over_limit_baseline: [a.png]

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/boolean-size.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "a.png": true

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/dot-segment.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "./a.png": 2000000

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/duplicate-path.yaml

@@ -0,0 +1,4 @@
+schema_version: 1
+over_limit_baseline:
+  "a.png": 2000000
+  "a.png": 9000000

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/empty-segment.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "a//b.png": 2000000

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/float-size.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "a.png": 2000000.5

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/negative-size.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "a.png": -5

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/no-over-limit-baseline.yaml

@@ -0,0 +1 @@
+schema_version: 1

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/no-schema-version.yaml

@@ -0,0 +1 @@
+over_limit_baseline: {}

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/non-string-path.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  1234: 2000000

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/not-yaml.yaml

@@ -0,0 +1,2 @@
+schema_version: 1
+over_limit_baseline: {unclosed

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/null-size.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "a.png":

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/parent-segment.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "../a.png": 2000000

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/string-size.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "a.png": '2000000'

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/top-level-is-a-list.yaml

@@ -0,0 +1,2 @@
+- 1
+- 2

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/trailing-slash.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "dir/": 2000000

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/unknown-key.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline: {}
+notes: x

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/wrong-schema-version.yaml

@@ -0,0 +1,2 @@
+schema_version: 2
+over_limit_baseline: {}

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/malformed/zero-size.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+over_limit_baseline:
+  "a.png": 0

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/lfs/integrity/fixtures/valid.yaml

@@ -0,0 +1,4 @@
+schema_version: 1
+over_limit_baseline:
+  photo.png: 2000000
+  "assets/large file.bin": 1500000