@amsterdamdatalabs/adl-agent-control-darwin-arm64 0.1.4

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/ci_paths/test_check.py

@@ -0,0 +1,274 @@
+"""LAY-002 -- ported from `compliance_new/checks/layout/ci-paths/test.sh`.
+
+`test.sh` is nine lines and asserts exactly one thing: dispatched through
+`_dispatch-contract.sh`'s `dispatch_contract`, an EMPTY given set runs the row
+to completion without crashing (exit 0 or 1, never 2). There is no
+`fixtures/` directory under `compliance_new/checks/layout/ci-paths/`, no
+inline `mktemp`/heredoc scenario, and no named input this check grades -- see
+`check.py`'s module docstring for the full search that established this. No
+`fixtures/` directory is committed here either, and nothing below claims to
+be "what `test.sh` asserts" beyond the one empty-set case.
+
+What IS tested below, and why none of it is an invented detection scenario:
+
+  - the row's own wiring (script/test paths, domain, name) -- ordinary, cheap,
+    and independent of whether the check itself is correct;
+  - the ported algorithm's pure functions (`_is_surface`, the token exclusion
+    predicate, the `.gitignore` translate/compile/decide chain) against their
+    OWN specification -- check.sh's literal awk source for the former, and
+    `gitignore(5)`'s documented grammar for the latter (the same grammar
+    `checks/repository/ignored_paths` already tests the identical way);
+  - two plumbing tests built from `tmp_path` (never committed, never claimed
+    as a corpus) that exercise the real reach mechanism `check.py`'s module
+    docstring documents -- a `.gitignore` genuinely present in LAY-002's own
+    `engine.scope` at `.workflows/config/coverage/.gitignore` -- and its
+    stated absence-reduction. These prove the port's own plumbing is
+    self-consistent; they are not a reconstruction of a shell scenario that
+    was never written.
+
+This check is not yet wired into `checks/__init__.py` (a later step wires
+this port's whole wave into the registry in one shot); every test below calls
+`CiPaths().run(...)` directly and assembles the verdict with `decide()`
+itself, the same bypass `checks/repository/ignored_paths` and
+`checks/layout/scripts_size_depth` already use for the identical reason.
+"""
+
+from __future__ import annotations
+
+import re
+
+from adl_compliance.checks.layout.ci_paths import CiPaths
+from adl_compliance.checks.layout.ci_paths.check import _compile_rule, _translate
+from adl_compliance.core.context import Context, FileSet
+from adl_compliance.core.verdict import Outcome, decide
+from adl_compliance.policy.registry import load
+
+from helpers import corpus
+
+ROW = load().by_id("LAY-002")
+
+
+def run_directly(root, paths: tuple[str, ...]):
+    # `workflows_root` is a RESOLVED INPUT now, not a class constant --
+    # `.workflows`, the packaged default's shape, which every fixture below
+    # already uses.
+    ctx = Context(root=root, row=ROW, inputs={"workflows_root": root / ".workflows"})
+    findings = tuple(CiPaths().run(ctx, FileSet(paths=paths)))
+    return decide(ROW, findings, 0, ())
+
+
+# --- the row itself -----------------------------------------------------------
+
+
+def test_the_row_identifies_this_check() -> None:
+    assert ROW.domain == "layout"
+    assert ROW.name == "ci-paths"
+
+
+# --- what test.sh itself proves: an empty set runs, clean, never crashing -----
+
+
+def test_an_empty_given_set_is_a_clean_pass(tmp_path) -> None:
+    """The Python equivalent of `dispatch_contract layout.ci-paths
+    pr_validation`: no `ADL_CHANGED_FILES`-unset state exists here (a
+    `FileSet` is always given, never absent), so the shell guard that refuses
+    to run does not port -- what carries over is the ONE thing the shell
+    dispatch test actually observes: the row resolves and runs to a decided,
+    non-crashing verdict."""
+    verdict = run_directly(tmp_path, ())
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+
+
+# --- `_is_surface`: which given files are CI surfaces at all ------------------
+
+
+# `_is_surface`'s second argument is a RESOLVED set now, not a class constant
+# -- the packaged default's shape, spelled out here because the TEST is
+# declaring what it expects, not the implementation hardcoding a consumer path.
+PACKAGED_PIPELINE_SURFACES = frozenset(
+    {".workflows/pipelines/pr-validation.yaml", ".workflows/pipelines/qua-cd.yaml"}
+)
+
+
+def test_the_two_named_pipeline_definitions_are_surfaces() -> None:
+    check = CiPaths()
+    assert check._is_surface(".workflows/pipelines/pr-validation.yaml", PACKAGED_PIPELINE_SURFACES)
+    assert check._is_surface(".workflows/pipelines/qua-cd.yaml", PACKAGED_PIPELINE_SURFACES)
+
+
+def test_an_ordinary_shell_script_outside_tests_is_a_surface() -> None:
+    assert CiPaths()._is_surface(".workflows/scripts/hooks/setup.sh", frozenset())
+
+
+def test_a_shell_script_under_tests_is_not_a_surface() -> None:
+    """The case pattern `tests/*) continue ;;` is checked before `*.sh`."""
+    assert not CiPaths()._is_surface("tests/fixture.sh", frozenset())
+
+
+def test_a_non_shell_non_pipeline_file_is_not_a_surface() -> None:
+    assert not CiPaths()._is_surface(".workflows/config/coverage/summary.json", frozenset())
+
+
+# --- the token exclusion predicate ---------------------------------------------
+
+
+def test_an_http_prefixed_token_is_excluded() -> None:
+    assert CiPaths()._excluded("http/example/path", frozenset({"http"}))
+
+
+def test_a_docker_registry_reference_is_excluded() -> None:
+    assert CiPaths()._excluded(
+        "123456789.dkr.ecr.us-east-1.amazonaws.com/repo", frozenset()
+    )
+
+
+def test_donors_and_target_prefixed_tokens_are_excluded() -> None:
+    check = CiPaths()
+    assert check._excluded(".donors/enact-upstream/README.md", frozenset({".donors"}))
+    assert check._excluded("target/debug/enactrs", frozenset({"target"}))
+
+
+def test_a_token_whose_first_segment_is_not_a_real_root_entry_is_excluded() -> None:
+    """`root[]` is a token-validity predicate, not scope: a version-looking
+    string with a slash in it is not a repository path at all."""
+    assert CiPaths()._excluded("v1.2/release", frozenset({"backend", "frontend"}))
+
+
+def test_a_token_whose_first_segment_is_a_real_root_entry_survives() -> None:
+    assert not CiPaths()._excluded(
+        "backend/crates/enact-db/src/lib.rs", frozenset({"backend", "frontend"})
+    )
+
+
+def test_tokens_extract_from_a_line_after_url_stripping() -> None:
+    check = CiPaths()
+    line = check.URL_RE.sub("", "curl https://example.com/a/b && cat backend/README.md")
+    tokens = list(check._tokens(line, frozenset({"backend"})))
+    assert tokens == ["backend/README.md"]
+
+
+# --- the `.gitignore` pattern engine, against gitignore(5)'s own grammar ------
+
+
+def test_a_directory_pattern_matches_only_paths_beneath_it() -> None:
+    rule = _compile_rule("node_modules/", "")
+    assert rule is not None
+    assert rule.regex.match("node_modules/pkg/index.js")
+    assert not rule.regex.match("node_modules")
+    assert not rule.regex.match("not-node_modules/x")
+
+
+def test_a_slash_free_pattern_matches_at_any_depth() -> None:
+    rule = _compile_rule("*.log", "")
+    assert rule is not None
+    assert rule.regex.match("debug.log")
+    assert rule.regex.match("nested/dir/debug.log")
+    assert not rule.regex.match("debug.logx")
+
+
+def test_a_comment_and_a_blank_line_compile_to_nothing() -> None:
+    assert _compile_rule("# a comment", "") is None
+    assert _compile_rule("", "") is None
+    assert _compile_rule("   ", "") is None
+
+
+def test_a_leading_bang_negates_and_a_leading_escaped_bang_does_not() -> None:
+    negated = _compile_rule("!keep.log", "")
+    literal = _compile_rule("\\!literal-bang", "")
+    assert negated is not None and negated.negated is True
+    assert literal is not None and literal.negated is False
+    assert literal.regex.match("!literal-bang")
+
+
+def test_star_never_crosses_a_path_separator() -> None:
+    assert _translate("*") == "[^/]*"
+    assert re.compile(f"^{_translate('*')}$").match("a") is not None
+    assert re.compile(f"^{_translate('*')}$").match("a/b") is None
+
+
+# --- `_is_ignored`: the LAST matching rule decides, and it can negate --------
+
+
+def test_the_decision_helper_honours_directory_scoped_precedence() -> None:
+    check = CiPaths()
+    shallow = _compile_rule("*.log", "")
+    deep = _compile_rule("!keep.log", "reports")
+    assert shallow is not None and deep is not None
+    assert check._is_ignored("debug.log", [shallow])
+    assert not check._is_ignored("reports/keep.log", [shallow, deep])
+    assert check._is_ignored("reports/other.log", [shallow, deep])
+
+
+# --- the end-to-end pipeline, built only from `.gitignore` files IN THE SET ---
+
+
+def test_a_gitignore_present_in_the_given_set_drives_a_real_finding(tmp_path) -> None:
+    """Not an invented detection scenario -- the mechanism `check.py`'s module
+    docstring documents as real for this row: `.workflows/config/coverage/
+    .gitignore` is a genuine, committed nested `.gitignore` inside LAY-002's
+    own `engine.scope`, so a `.gitignore` DOES land in an exhaustive given
+    set. This proves the plumbing end to end using exactly that shape,
+    against synthetic content, not a claim about what `test.sh` asserts."""
+    surface = tmp_path / ".workflows" / "scripts" / "probe.sh"
+    surface.parent.mkdir(parents=True)
+    surface.write_text("cat .workflows/config/coverage/summary.json\n", encoding="utf-8")
+
+    ignore = tmp_path / ".workflows" / "config" / "coverage" / ".gitignore"
+    ignore.parent.mkdir(parents=True)
+    ignore.write_text("summary.json\n", encoding="utf-8")
+
+    given = (
+        ".workflows/scripts/probe.sh",
+        ".workflows/config/coverage/.gitignore",
+    )
+    verdict = run_directly(tmp_path, given)
+    assert verdict.outcome is Outcome.FINDINGS, verdict.render()
+    assert verdict.rules == ["LAY-002"]
+    finding = verdict.findings[0]
+    assert finding.path == ".workflows/scripts/probe.sh"
+    assert "summary.json" in finding.message
+
+
+def test_a_redeclared_workflows_tree_still_treats_the_pipeline_files_as_surfaces() -> None:
+    """The SILENT false pass PIPELINE_NAMES shipped with.
+
+    PIPELINE_SURFACES was a set of hardcoded `.workflows/pipelines/...`
+    literals, tested for membership in `_is_surface`. A repository whose
+    workflows root is not the packaged default had its real pipeline
+    definitions fail that membership test -- they are `.yaml`, so they also
+    fail the `.sh` fallback -- and the gate never scanned them at all: clean,
+    having examined nothing.
+
+    Same shape as the `.gitignore`-in-the-set case above, but the CI surface
+    is the pipeline definition itself, under a redeclared `automation/`
+    workflows root: ungraded before the fix, caught after."""
+    # A COMMITTED corpus, not one this test writes. `tests/core/test_layout.py`
+    # requires a check declaring `inputs` to ship one, and its reason is sound:
+    # a corpus a reader can open beats content that only exists while the test
+    # runs. This check had none because it declared no inputs until the K-42
+    # fix gave it `workflows_root`.
+    root = corpus("layout", "ci-paths") / "redeclared-workflows-tree"
+
+    given = (
+        "automation/pipelines/pr-validation.yaml",
+        "automation/config/coverage/.gitignore",
+    )
+    ctx = Context(root=root, row=ROW, inputs={"workflows_root": root / "automation"})
+    findings = tuple(CiPaths().run(ctx, FileSet(paths=given)))
+    verdict = decide(ROW, findings, 0, ())
+    assert verdict.outcome is Outcome.FINDINGS, (
+        f"a real pipeline definition under a redeclared workflows root went "
+        f"unreported: {verdict.render()}"
+    )
+    assert verdict.findings[0].path == "automation/pipelines/pr-validation.yaml"
+
+
+def test_a_gitignore_outside_the_given_set_is_invisible(tmp_path) -> None:
+    """The stated reach reduction: without a `.gitignore` in the given set (or
+    at the repository root), this port has no rule to grade against."""
+    surface = tmp_path / ".workflows" / "scripts" / "probe.sh"
+    surface.parent.mkdir(parents=True)
+    surface.write_text("cat .workflows/config/coverage/summary.json\n", encoding="utf-8")
+
+    verdict = run_directly(tmp_path, (".workflows/scripts/probe.sh",))
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/__init__.py

@@ -0,0 +1,12 @@
+"""The `layout.directory-ratchet` gate.
+
+A folder rather than a module because this gate GRADES A DOCUMENT, and the
+document belongs beside the check that reads it. `check.py` is the rule;
+anything else in here is what it grades.
+"""
+
+from __future__ import annotations
+
+from .check import DirectoryRatchet
+
+__all__ = ["DirectoryRatchet"]

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/check.py

@@ -0,0 +1,227 @@
+"""LAY-004 — every registered tree's committed directory-shape ratchet.
+
+Two rules over one measurement — a directory's DIRECT FILE COUNT — plus the
+third rule that makes this check unlike any other ported so far:
+
+  DIR-001  over the tree's ceiling with no ratchet entry, or a single-file
+           directory with no ratchet entry.
+  DIR-002  over its own recorded entry, or its one file is not the one recorded.
+  DIR-003  a ratchet entry that is no longer required. **This grades ABSENCE.**
+
+DIR-003 is why this gate has no way to point it at one tree. A narrower set
+makes every unreachable entry look stale, so narrowing INFLATES the answer
+rather than reducing it: measured on this row, 7 findings over the registered
+trees against 92 when pointed at one crate. That is also why the row declares
+tree-scoped globs and why `runner.run(exhaustive=...)` matters here more than
+anywhere else — an empty intersection is a dead scope, not a clean tree.
+
+Children means FILES. A directory holding ten subdirectories and no files of
+its own has zero children; each subdirectory is counted separately by the same
+rule. Nothing here walks: every count is taken from the set the runner handed
+over, narrowed to one tree at a time.
+
+The register is package data, shipped beside this file as a `resources` entry
+(`grants.yaml`, resolved through `importlib.resources` like every other packaged
+input) — not a consumer path spelled through the row's `grants:` field. It is
+not a catalogue of signed exceptions either way, and `structural_grant` is what
+says so: see `Check.structural_grant` for why passing its size as an allowance
+turns a failing gate green.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Annotated, ClassVar, Literal
+
+from pydantic import Field
+
+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 Ratchet(StrictModel):
+    """The register. `max_children` is the list of trees this gate holds at
+    all, so an empty one is a gate grading nothing — a load failure, not a pass."""
+
+    schema_version: Literal[2]
+    """Locked, not just typed: a future bump must change this literal, which
+    makes it a deliberate, schema-revealing edit rather than a silent one."""
+
+    max_children: Annotated[dict[str, int], Field(min_length=1)]
+    over_children_baseline: dict[str, int] = {}
+    single_file_baseline: dict[str, str] = {}
+
+
+class DirectoryShape(StrictModel):
+    """One directory's measured shape, keyed by its repository-relative path."""
+
+    children: int
+    only: str
+    """The single child's basename. Meaningful only when `children == 1`."""
+
+
+class DirectoryRatchet(Check):
+    id: ClassVar[str] = "LAY-004"
+    structural_grant: ClassVar[bool] = True
+
+    # CONSUMER-OWNED, not package data. This shipped as a `resources` entry
+    # (`grants.yaml`) holding one donor repository's entire directory shape:
+    # 88 of its 104 lines named `<rust>/crates/enact-*`,
+    # `<typescript>/packages/desktop/src/renderer/*` and `infra/stacks/*`. None of
+    # the four repositories in this estate has any of those trees, so the gate
+    # raised could-not-run on its FIRST registered tree for every one of them.
+    #
+    # The old docstring defended the file as "not a consumer path". That is
+    # backwards: a ratchet baseline IS the consumer's own state by definition —
+    # "today's known exceptions" means today, in THIS repository. Shipping one
+    # repo's exceptions to every other repo is the K-42 defect with the largest
+    # blast radius found so far.
+    inputs: ClassVar[dict[str, str]] = {
+        "register": "<compliance>/ratchets/LAY-004-over-limit-directory.yaml",
+    }
+
+    OVER: ClassVar[str] = "DIR-001"
+    GREW: ClassVar[str] = "DIR-002"
+    STALE: ClassVar[str] = "DIR-003"
+
+    def graded(self, ctx: Context, files: FileSet) -> Iterable[Report]:
+        ratchet = self._register(ctx)
+
+        for tree, ceiling in sorted(ratchet.max_children.items()):
+            if not ctx.path(tree).is_dir():
+                raise CouldNotRun(f"registered tree directory is missing: {tree}")
+
+            measured = self._measure(ctx, files, tree)
+            # Each tree sees only its OWN entries. The register holds every
+            # tree's exceptions in one namespace, and a tree's measurement can
+            # never contain another tree's path — so without this filter every
+            # other tree's entries would report DIR-003 on every run.
+            over = self._entries_under(ratchet.over_children_baseline, tree)
+            single = self._entries_under(ratchet.single_file_baseline, tree)
+
+            yield from self._graded_over(measured, over, ceiling)
+            yield from self._graded_single(measured, single)
+
+    # ------------------------------------------------------------ the register
+
+    def _register(self, ctx: Context) -> Ratchet:
+        """The repository's own baseline — see `inputs` above."""
+        if not ctx.inputs["register"].is_file():
+            shown = ctx.relative(ctx.inputs["register"])
+            raise CouldNotRun(
+                f"no directory-ratchet register at {shown}; a ratchet grades a "
+                "repository against ITS OWN recorded shape, so there is nothing "
+                "to grade until this repository records one (or points "
+                "[controls.compliance.inputs].register at where it keeps it). "
+                "An absent baseline is could-not-run, never a clean pass"
+            )
+        try:
+            return self.parse_yaml(ctx, ctx.inputs["register"], Ratchet)
+        except SchemaInvalid as exc:
+            raise CouldNotRun(f"ratchet register is unusable: {exc.detail}") from exc
+
+    @staticmethod
+    def _entries_under(baseline: dict[str, object], tree: str) -> dict[str, object]:
+        return {
+            path: value for path, value in baseline.items()
+            if path == tree or path.startswith(f"{tree}/")
+        }
+
+    # ---------------------------------------------------------- the measurement
+
+    def _measure(self, ctx: Context, files: FileSet, tree: str) -> dict[str, DirectoryShape]:
+        """Direct file children per directory, from the given set alone.
+
+        `is_file` is a liveness check on ONE named path — a set may name a file
+        that has just been deleted — not a search for paths.
+        """
+        counts: dict[str, int] = {}
+        first: dict[str, str] = {}
+
+        for relative in sorted(files):
+            if not relative.startswith(f"{tree}/"):
+                continue
+            if not ctx.path(relative).is_file():
+                continue
+            inside = relative[len(tree) + 1:]
+            parts = inside.split("/")
+            # A dot-prefixed component anywhere excludes the file, matching the
+            # walker every other tool in this repository uses.
+            if any(part.startswith(".") for part in parts):
+                continue
+            parent = "/".join([tree, *parts[:-1]]) if len(parts) > 1 else tree
+            counts[parent] = counts.get(parent, 0) + 1
+            if counts[parent] == 1:
+                first[parent] = parts[-1]
+
+        return {
+            path: DirectoryShape(children=count, only=first[path])
+            for path, count in counts.items()
+        }
+
+    # ---------------------------------------------------------------- the rules
+
+    def _graded_over(
+        self, measured: dict[str, DirectoryShape], baseline: dict[str, object], ceiling: int
+    ) -> Iterable[Report]:
+        for path, shape in sorted(measured.items()):
+            if shape.children > ceiling and path not in baseline:
+                yield self.report(
+                    path,
+                    f"{shape.children} direct children (max {ceiling}), no ratchet entry",
+                    f"add an over_children_baseline entry for {path} to the ratchet "
+                    "register, or split the directory",
+                    rule=self.OVER,
+                )
+            recorded = baseline.get(path)
+            if isinstance(recorded, int) and shape.children > recorded:
+                yield self.report(
+                    path, f"{shape.children} direct children (baseline {recorded})",
+                    f"reduce {path} back to at most {recorded} children, or raise its "
+                    "over_children_baseline entry",
+                    rule=self.GREW,
+                )
+
+        for path in sorted(baseline):
+            shape = measured.get(path)
+            if shape is None or shape.children <= ceiling:
+                yield self.report(
+                    path, "ratchet entry is no longer required",
+                    f"delete {path}'s stale over_children_baseline entry from the "
+                    "ratchet register",
+                    rule=self.STALE,
+                )
+
+    def _graded_single(
+        self, measured: dict[str, DirectoryShape], baseline: dict[str, object]
+    ) -> Iterable[Report]:
+        for path, shape in sorted(measured.items()):
+            if shape.children != 1:
+                continue
+            if path not in baseline:
+                yield self.report(
+                    path, "single-file directory, no ratchet entry",
+                    f"add a single_file_baseline entry for {path} naming its one file "
+                    "in the ratchet register",
+                    rule=self.OVER,
+                )
+            elif shape.only != baseline[path]:
+                yield self.report(
+                    path, f"single child is {shape.only} (baseline {baseline[path]})",
+                    f"update the single_file_baseline entry for {path} to {shape.only}, "
+                    "or restore the original file",
+                    rule=self.GREW,
+                )
+
+        for path in sorted(baseline):
+            shape = measured.get(path)
+            if shape is None or shape.children != 1:
+                yield self.report(
+                    path, "ratchet entry is no longer required",
+                    f"delete {path}'s stale single_file_baseline entry from the "
+                    "ratchet register",
+                    rule=self.STALE,
+                )

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-clean/frontend/packages/desktop/src/renderer/solo/item.ts

@@ -0,0 +1 @@
+export const item = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-clean/grants.yaml

@@ -0,0 +1,6 @@
+schema_version: 2
+max_children:
+  frontend/packages/desktop/src: 10
+over_children_baseline: {}
+single_file_baseline:
+  frontend/packages/desktop/src/renderer/solo: item.ts

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/fresh/fresh.ts

@@ -0,0 +1 @@
+export const fresh = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub1/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub10/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub11/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub2/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub3/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub4/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub5/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub6/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub7/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub8/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/many/sub9/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/services/i18n/locales/de/common.json

@@ -0,0 +1 @@
+{"a":1}

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/renderer/solo/item.ts

@@ -0,0 +1 @@
+export const item = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/frontend/packages/desktop/src/vendored-crate/Cargo.toml

@@ -0,0 +1,2 @@
+[package]
+name = "x"

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-excluded/grants.yaml

@@ -0,0 +1,6 @@
+schema_version: 2
+max_children:
+  frontend/packages/desktop/src: 20
+over_children_baseline: {}
+single_file_baseline:
+  frontend/packages/desktop/src/renderer/solo: item.ts

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/fresh/fresh.ts

@@ -0,0 +1 @@
+export const fresh = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub1/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub10/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub11/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub2/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub3/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub4/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub5/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub6/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub7/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub8/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/many/sub9/only.ts

@@ -0,0 +1 @@
+export const v = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/frontend/packages/desktop/src/renderer/solo/item.ts

@@ -0,0 +1 @@
+export const item = 1;

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/fixtures/directory-ratchet-unbaselined/grants.yaml

@@ -0,0 +1,6 @@
+schema_version: 2
+max_children:
+  frontend/packages/desktop/src: 10
+over_children_baseline: {}
+single_file_baseline:
+  frontend/packages/desktop/src/renderer/solo: item.ts