gitcad-core 0.7.7__py3-none-any.whl

gitcad/part/lockfile.py

@@ -0,0 +1,133 @@
+"""Dependency resolution and the lockfile (ADR-0009).
+
+A dependency is an intent constraint (`^1.4`); the lock pins the exact resolved
+version *and its canonical-text content hash*, so a build is byte-reproducible
+from a git tag forever. Resolution is deliberately simple in v1: highest
+available version satisfying the constraint, from a local Workspace (a
+directory of part.json files). The registry (ADR-0010) slots in behind the
+same Workspace shape later.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from gitcad.canonical import canonical_json
+from gitcad.errors import GitcadError
+from gitcad.part.manifest import PartManifest
+from gitcad.part.semver import Version, satisfies
+
+
+class Workspace:
+    """All known part versions, keyed by part id. v1 source: a directory tree
+    scanned for ``*.part.json`` / ``part.json`` files."""
+
+    def __init__(self) -> None:
+        self._versions: dict[str, dict[str, PartManifest]] = {}
+
+    def add(self, manifest: PartManifest) -> None:
+        self._versions.setdefault(manifest.id, {})[manifest.version] = manifest
+
+    @classmethod
+    def scan(cls, root: str) -> "Workspace":
+        ws = cls()
+        for path in sorted(Path(root).rglob("*part.json")):
+            ws.add(PartManifest.loads(path.read_text()))
+        return ws
+
+    @classmethod
+    def from_git(cls, url: str, *, ref: str = "main", cache_dir: str | None = None) -> "Workspace":
+        """A workspace backed by a git registry (e.g. gitcad-xyz/registry).
+
+        Shallow-clones (or updates) into a local cache and scans it — the
+        registry IS a git repo (ADR-0010), so the client is just git + scan.
+        Resolution then pins content hashes (ADR-0009) exactly as with any
+        local workspace.
+        """
+        import hashlib
+        import subprocess
+        import tempfile
+
+        key = hashlib.blake2b(f"{url}#{ref}".encode(), digest_size=8).hexdigest()
+        dest = Path(cache_dir) if cache_dir else Path(tempfile.gettempdir()) / "gitcad-registry" / key
+        if (dest / ".git").exists():
+            subprocess.run(["git", "-C", str(dest), "fetch", "--depth", "1", "origin", ref],
+                           check=True, capture_output=True)
+            subprocess.run(["git", "-C", str(dest), "checkout", "-q", "FETCH_HEAD"],
+                           check=True, capture_output=True)
+        else:
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            subprocess.run(["git", "clone", "--depth", "1", "--branch", ref, url, str(dest)],
+                           check=True, capture_output=True)
+        return cls.scan(str(dest))
+
+    def versions_of(self, part_id: str) -> list[str]:
+        return sorted(self._versions.get(part_id, {}), key=Version.parse)
+
+    def get(self, part_id: str, version: str) -> PartManifest:
+        try:
+            return self._versions[part_id][version]
+        except KeyError:
+            raise GitcadError(f"workspace has no {part_id}@{version}") from None
+
+
+@dataclass
+class Lockfile:
+    """{part id: {version, content}} — committed next to the consumer."""
+
+    locks: dict[str, dict[str, str]] = field(default_factory=dict)
+
+    SCHEMA = "gitcad/lock@1"
+
+    def dumps(self) -> str:
+        return canonical_json({"schema": self.SCHEMA, "locks": self.locks}, indent=2) + "\n"
+
+    @classmethod
+    def loads(cls, text: str) -> "Lockfile":
+        doc = json.loads(text)
+        if doc.get("schema") != cls.SCHEMA:
+            raise GitcadError(f"unsupported lock schema {doc.get('schema')!r}")
+        return cls(locks=dict(doc["locks"]))
+
+    def verify(self, workspace: Workspace) -> list[str]:
+        """Confirm every locked hash still matches the workspace content —
+        catches tampering and accidental drift. Empty list = sound."""
+        problems: list[str] = []
+        for part_id, entry in sorted(self.locks.items()):
+            try:
+                manifest = workspace.get(part_id, entry["version"])
+            except GitcadError:
+                problems.append(f"missing:{part_id}@{entry['version']}")
+                continue
+            actual = manifest.content_hash()
+            if actual != entry["content"]:
+                problems.append(f"hash-mismatch:{part_id}@{entry['version']}")
+        return problems
+
+
+def resolve(consumer: PartManifest, workspace: Workspace) -> Lockfile:
+    """Resolve ``consumer.deps`` (and transitively their deps) against the
+    workspace: highest version satisfying each constraint. Deterministic —
+    same workspace + same manifest → identical lockfile."""
+    lock = Lockfile()
+    queue = list(consumer.deps.items())
+    while queue:
+        part_id, constraint = queue.pop(0)
+        candidates = [v for v in workspace.versions_of(part_id) if satisfies(v, constraint)]
+        if not candidates:
+            raise GitcadError(
+                f"unresolvable: {part_id} {constraint!r} "
+                f"(available: {workspace.versions_of(part_id) or 'none'})"
+            )
+        chosen = candidates[-1]  # versions_of is sorted ascending
+        prior = lock.locks.get(part_id)
+        if prior is not None:
+            if prior["version"] != chosen and not satisfies(prior["version"], constraint):
+                raise GitcadError(f"conflict: {part_id} locked {prior['version']}, needs {constraint}")
+            continue
+        manifest = workspace.get(part_id, chosen)
+        lock.locks[part_id] = {"version": chosen, "content": manifest.content_hash()}
+        queue.extend(manifest.deps.items())
+    return lock

gitcad/part/manifest.py

@@ -0,0 +1,77 @@
+"""The part manifest — ``part.json`` (ADR-0008).
+
+Domain-neutral wrapper every part carries: identity, version, interface, deps,
+and an opaque domain-specific body core never parses. Canonical serialization
+and content hashing follow the same rules as the document model (ADR-0004):
+byte-stable text is what makes locks, diffs, and releases trustworthy.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import secrets
+from dataclasses import dataclass, field
+
+from gitcad.canonical import canonical_json
+from gitcad.errors import GitcadError
+from gitcad.part.interface import Interface
+from gitcad.part.semver import Version
+
+KNOWN_DOMAINS = {"mech", "ecad", "ecad.component", "assembly"}  # open set; these get validation
+
+
+def new_part_id() -> str:
+    """Mint a part id. Assigned once at creation and stable forever — never
+    derived from name or path (ADR-0003 discipline, one level up)."""
+    return "prt_" + secrets.token_hex(8)
+
+
+@dataclass
+class PartManifest:
+    id: str
+    name: str
+    domain: str
+    version: str
+    interface: Interface = field(default_factory=Interface)
+    deps: dict[str, str] = field(default_factory=dict)   # part id -> constraint
+    body: dict = field(default_factory=dict)
+
+    SCHEMA = "gitcad/part@1"
+
+    def __post_init__(self) -> None:
+        if not self.id.startswith("prt_"):
+            raise GitcadError(f"part id must start with 'prt_': {self.id!r}")
+        Version.parse(self.version)  # validates
+
+    def dumps(self) -> str:
+        doc = {
+            "schema": self.SCHEMA,
+            "id": self.id,
+            "name": self.name,
+            "domain": self.domain,
+            "version": self.version,
+            "interface": self.interface.to_dict(),
+            "deps": dict(sorted(self.deps.items())),
+            "body": self.body,
+        }
+        return canonical_json(doc, indent=2) + "\n"
+
+    @classmethod
+    def loads(cls, text: str) -> "PartManifest":
+        doc = json.loads(text)
+        if doc.get("schema") != cls.SCHEMA:
+            raise GitcadError(f"unsupported part schema {doc.get('schema')!r}")
+        return cls(
+            id=doc["id"],
+            name=doc["name"],
+            domain=doc["domain"],
+            version=doc["version"],
+            interface=Interface.from_dict(doc["interface"]),
+            deps=dict(doc.get("deps", {})),
+            body=dict(doc.get("body", {})),
+        )
+
+    def content_hash(self) -> str:
+        """Hash of the canonical text — what the lockfile pins (ADR-0009)."""
+        return "blake2b:" + hashlib.blake2b(self.dumps().encode(), digest_size=16).hexdigest()

gitcad/part/matesolve.py

@@ -0,0 +1,88 @@
+"""mate_solve — place instances by mate intent (ADR-0014, authoring-time).
+
+The build never solves; it only checks. This tool runs at authoring time,
+computes the rigid translation that makes each mated port pair coincide,
+and writes the solved transforms back into the assembly — which then
+validates like any hand-placed assembly. Rotation is respected but not
+solved (v1: rotate_z_deg stays what the author set; the solve moves, it
+does not spin — spinning has branch multiplicity, translation does not).
+
+Traversal is BFS from a base instance (the most-mated, ties by name — the
+same deterministic choice auto_explode makes). A mate between two
+already-placed instances becomes a CHECK: if their ports don't coincide,
+that's an over-constraint conflict, reported with the gap, never "fixed"
+by silently moving something the solver already placed.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+
+from gitcad.part.assembly import Assembly
+
+
+@dataclass
+class MateSolveReport:
+    base: str = ""
+    solved: list[str] = field(default_factory=list)      # instances moved
+    unreachable: list[str] = field(default_factory=list)  # no mate path to base
+    conflicts: list[str] = field(default_factory=list)   # "a.p<->b.q:gap=..mm"
+
+    @property
+    def ok(self) -> bool:
+        return not self.conflicts
+
+    def to_dict(self) -> dict:
+        return {"base": self.base, "solved": self.solved,
+                "unreachable": self.unreachable,
+                "conflicts": self.conflicts, "ok": self.ok}
+
+
+def mate_solve(asm: Assembly, *, base: str | None = None,
+               tol: float = 1e-6) -> MateSolveReport:
+    """Solve instance translations so mated ports coincide. Mutates ``asm``
+    (authoring writes back into reviewable text); returns the report."""
+    report = MateSolveReport()
+    if not asm.instances:
+        return report
+
+    adj: dict[str, list[tuple[str, str, str]]] = {n: [] for n in asm.instances}
+    for mate in asm.mates:
+        (ia, pa), (ib, pb) = mate.split()
+        adj[ia].append((ib, pa, pb))
+        adj[ib].append((ia, pb, pa))
+
+    if base is None:
+        base = max(adj, key=lambda n: (len(adj[n]), n))
+    report.base = base
+
+    placed = {base}
+    queue = [base]
+    while queue:
+        cur = queue.pop(0)
+        for other, cur_port, other_port in sorted(adj[cur]):
+            anchor = asm.instances[cur].port_position(cur_port)
+            inst = asm.instances[other]
+            if other in placed:
+                # over-constraint: verify instead of move
+                have = inst.port_position(other_port)
+                gap = math.dist(anchor, have)
+                if gap > tol:
+                    a, b = sorted([f"{cur}.{cur_port}", f"{other}.{other_port}"])
+                    entry = f"{a}<->{b}:gap={gap:.6g}mm"
+                    if entry not in report.conflicts:
+                        report.conflicts.append(entry)
+                continue
+            # port position with zero translate = local (rotated) port offset
+            local = tuple(p - t for p, t in
+                          zip(inst.port_position(other_port), inst.translate))
+            inst.translate = tuple(round(a - l, 9) for a, l in zip(anchor, local))
+            placed.add(other)
+            report.solved.append(other)
+            queue.append(other)
+
+    report.unreachable = sorted(set(asm.instances) - placed)
+    report.solved.sort()
+    report.conflicts.sort()
+    return report

gitcad/part/semver.py

@@ -0,0 +1,81 @@
+"""Semantic versions and dependency constraints (ADR-0009).
+
+Small on purpose: exactly the subset the lockfile needs — `^` (compatible),
+`~` (patch-level), exact, and `*`. No pre-release/build tags in v1.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from functools import total_ordering
+
+from gitcad.errors import GitcadError
+
+_VERSION_RE = re.compile(r"^(\d+)\.(\d+)\.(\d+)$")
+
+BUMPS = ("patch", "minor", "major")
+
+
+@total_ordering
+@dataclass(frozen=True)
+class Version:
+    major: int
+    minor: int
+    patch: int
+
+    @classmethod
+    def parse(cls, text: str) -> "Version":
+        m = _VERSION_RE.match(text.strip())
+        if not m:
+            raise GitcadError(f"invalid version {text!r} (want MAJOR.MINOR.PATCH)")
+        return cls(int(m.group(1)), int(m.group(2)), int(m.group(3)))
+
+    def __str__(self) -> str:
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+    def __lt__(self, other: "Version") -> bool:
+        return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
+
+    def bump(self, kind: str) -> "Version":
+        if kind == "major":
+            return Version(self.major + 1, 0, 0)
+        if kind == "minor":
+            return Version(self.major, self.minor + 1, 0)
+        if kind == "patch":
+            return Version(self.major, self.minor, self.patch + 1)
+        raise GitcadError(f"unknown bump kind {kind!r}")
+
+    def actual_bump_from(self, old: "Version") -> str | None:
+        """What kind of bump this version is relative to ``old`` — or None if
+        it isn't a single well-formed bump (arbitrary jumps are allowed but
+        classified by the highest changed field)."""
+        if self <= old:
+            return None
+        if self.major > old.major:
+            return "major"
+        if self.minor > old.minor:
+            return "minor"
+        return "patch"
+
+
+def satisfies(version: Version | str, constraint: str) -> bool:
+    """Does ``version`` satisfy ``constraint``? (`^x.y.z`, `~x.y.z`, exact, `*`)"""
+    v = Version.parse(version) if isinstance(version, str) else version
+    c = constraint.strip()
+    if c == "*":
+        return True
+    if c.startswith("^"):
+        base = Version.parse(c[1:])
+        if base.major > 0:
+            return base <= v < Version(base.major + 1, 0, 0)
+        if base.minor > 0:
+            # ^0.y.z: 0.x treats minor as breaking (npm/cargo convention)
+            return base <= v < Version(0, base.minor + 1, 0)
+        # ^0.0.z: exact only — every 0.0.x may break (npm/cargo convention;
+        # deviation was flagged in the 2026-07-22 review)
+        return v == base
+    if c.startswith("~"):
+        base = Version.parse(c[1:])
+        return base <= v < Version(base.major, base.minor + 1, 0)
+    return v == Version.parse(c)

gitcad/report/__init__.py

@@ -0,0 +1,20 @@
+"""Privacy-preserving bug reporting.
+
+The rule (ADR-0007): a submitted issue must include a *repro*, but users will not
+upload proprietary designs — so the local agent **reduces** the failing model to
+a minimal, synthetic case unrelated to the user's work, and the user approves the
+exact payload before anything leaves the machine.
+
+- :mod:`gitcad.report.fingerprint` — deterministic failure keys for dedup.
+- :mod:`gitcad.report.reduce` — delta-debugging reducer (the local "recreate it
+  in a simple design" step, done by an agent, not a human).
+"""
+
+from gitcad.report.fingerprint import fingerprint
+
+# reduce/scrub operate on mech Documents and import gitcad.document — they are
+# NOT re-exported here so gitcad-core stays importable standalone (the registry
+# installs core only). Import them directly: gitcad.report.reduce / .scrub —
+# which requires gitcad-mech installed.
+
+__all__ = ["fingerprint"]

gitcad/report/fingerprint.py

@@ -0,0 +1,22 @@
+"""Deterministic failure fingerprints.
+
+A fingerprint is the dedup key: 10,000 users hitting one kernel bug must produce
+one issue. It is derived only from *what went wrong* — the failing operation and
+the kernel's own diagnostic class — never from user coordinates, so it is both
+safe to transmit and stable across unrelated models (ADR-0006/0007).
+
+The occurrence count of a fingerprint is the priority signal — strictly better
+triage than raw report volume.
+"""
+
+from __future__ import annotations
+
+import hashlib
+
+from gitcad.errors import FailureSignature
+
+
+def fingerprint(signature: FailureSignature) -> str:
+    """A short, stable id for a failure class. Same (kernel, op, diagnostic) →
+    same fingerprint, on every machine."""
+    return "fp_" + hashlib.blake2b(signature.key().encode(), digest_size=10).hexdigest()

gitcad/report/reduce.py

@@ -0,0 +1,88 @@
+"""Delta-debugging reducer — proprietary model → minimal synthetic repro.
+
+This is the "someone local recreates the bug in a simple, unrelated design" step
+from the design discussion, done automatically. It is a near-perfect agent task:
+a mechanical search with a crisp, deterministic oracle ("does the failure still
+fingerprint the same?"), so no judgment is required and every step is verifiable.
+
+Algorithm: a ddmin-style greedy minimization over the feature list. Repeatedly
+try removing subsets of features; keep any removal that *preserves the same
+failure fingerprint*. Terminate at a 1-minimal document (no single further
+feature can be removed without changing the failure).
+
+IMPORTANT: ``ReductionResult.minimal`` is a subset of the user's actual
+features with the user's actual dimensions — NOT yet safe to transmit. The
+transmit-safety gate is :func:`gitcad.report.scrub.prepare_submission`
+(scrub + verify-twice, ADR-0007 steps 3-4).
+
+Nothing here transmits anything. The output is a candidate payload for the user
+to inspect and approve (ADR-0007).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from gitcad.document import Document, Feature
+
+# An oracle takes a candidate document and returns the failure fingerprint it
+# produces, or None if it no longer fails. Supplied by the caller so the reducer
+# stays kernel-agnostic and testable with a synthetic oracle.
+Oracle = Callable[[Document], "str | None"]
+
+
+@dataclass
+class ReductionResult:
+    minimal: Document
+    fingerprint: str
+    original_size: int
+    minimal_size: int
+    steps: int
+
+
+def _rebuild(features: list[Feature]) -> Document:
+    """Rebuild a document from a feature subset, dropping features whose inputs
+    were removed (so the tree stays well-formed after deletions)."""
+    doc = Document()
+    kept: set[str] = set()
+    for f in features:
+        if all(ref in kept for ref in f.inputs):
+            # Re-add preserving the original id for stable fingerprinting.
+            doc._features.append(f)          # noqa: SLF001 - internal rebuild
+            doc._by_id[f.id] = f             # noqa: SLF001
+            kept.add(f.id)
+    return doc
+
+
+def reduce_document(doc: Document, oracle: Oracle) -> ReductionResult:
+    """Greedily minimize ``doc`` while preserving its failure fingerprint."""
+    target = oracle(doc)
+    if target is None:
+        raise ValueError("document does not reproduce a failure; nothing to reduce")
+
+    features = list(doc.features)
+    steps = 0
+    changed = True
+    while changed:
+        changed = False
+        i = 0
+        while i < len(features):
+            candidate_features = features[:i] + features[i + 1 :]
+            candidate = _rebuild(candidate_features)
+            steps += 1
+            if oracle(candidate) == target:
+                # Removing feature i preserved the failure — keep it removed.
+                features = list(candidate.features)
+                changed = True
+            else:
+                i += 1
+
+    minimal = _rebuild(features)
+    return ReductionResult(
+        minimal=minimal,
+        fingerprint=target,
+        original_size=len(doc),
+        minimal_size=len(minimal),
+        steps=steps,
+    )

gitcad/report/scrub.py

@@ -0,0 +1,116 @@
+"""Scrub + similarity check — ADR-0007 steps 3 and 4, the transmit-safety gate.
+
+The reducer (:mod:`.reduce`) produces a *subset of the user's actual features
+with the user's actual dimensions* — NOT yet safe to transmit. This module
+finishes the pipeline:
+
+- :func:`scrub` rewrites the minimal repro with sanitized dimensions (rounded
+  to coarse values), stripped non-essential string params (file paths, names),
+  and re-minted ids — then re-runs the oracle to confirm the failure survived
+  sanitization.
+- :func:`similarity` measures how much of the original design leaks into the
+  candidate: surviving feature fraction and shared exact dimension values.
+
+:func:`prepare_submission` combines both into a verdict: a payload is
+``transmit_safe`` only if the scrubbed repro still fingerprints identically
+AND resembles the original weakly enough. When it isn't safe, the honest
+fallback is a fingerprint-only report (ADR-0007) — never "ship it anyway".
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from gitcad.document import Document, Feature
+from gitcad.report.reduce import Oracle, ReductionResult, reduce_document
+
+# String params that carry user context and are never needed to reproduce a
+# geometry-kernel failure class.
+_STRING_DENYLIST = {"file", "sha256", "name", "label", "comment"}
+
+# Feature-count and dimension-overlap ceilings for "does not resemble the
+# original". Conservative on purpose; ADR-0007 says precision over recall.
+_MAX_SURVIVING_FRACTION = 0.34
+_MAX_DIM_OVERLAP = 0.5
+# A repro this small is inherently non-identifying — the fraction test only
+# applies above it (2 features of a 5-feature doc is 40% but reveals nothing;
+# 200 features of a 500-feature design is a different matter).
+_SMALL_REPRO_FEATURES = 5
+
+
+def _scrub_value(v, ndigits: int):
+    if isinstance(v, bool):
+        return v
+    if isinstance(v, (int, float)):
+        return round(float(v), ndigits)
+    if isinstance(v, (list, tuple)):
+        return [_scrub_value(x, ndigits) for x in v]
+    return v
+
+
+def scrub(doc: Document, *, ndigits: int = 1) -> Document:
+    """Sanitized copy: dimensions coarsened, contextual strings stripped,
+    ids re-minted from the scrubbed values."""
+    out = Document()
+    id_map: dict[str, str] = {}
+    for f in doc.features:
+        params = {k: _scrub_value(v, ndigits)
+                  for k, v in f.params.items() if k not in _STRING_DENYLIST}
+        new_id = out.add(Feature(op=f.op, params=params,
+                                 inputs=[id_map[i] for i in f.inputs]))
+        id_map[f.id] = new_id
+    return out
+
+
+def similarity(original: Document, candidate: Document) -> dict[str, float]:
+    """How much of the original leaks into the candidate. Auditable numbers,
+    not a verdict — :func:`prepare_submission` applies the thresholds."""
+    surviving = len(candidate) / len(original) if len(original) else 0.0
+    orig_dims = {round(float(v), 6) for f in original.features
+                 for v in f.params.values() if isinstance(v, (int, float)) and not isinstance(v, bool)}
+    cand_dims = {round(float(v), 6) for f in candidate.features
+                 for v in f.params.values() if isinstance(v, (int, float)) and not isinstance(v, bool)}
+    dim_overlap = (len(orig_dims & cand_dims) / len(cand_dims)) if cand_dims else 0.0
+    return {"surviving_feature_fraction": round(surviving, 3),
+            "dimension_overlap": round(dim_overlap, 3)}
+
+
+@dataclass
+class Submission:
+    """The candidate bug-report payload plus its transmit-safety verdict."""
+
+    fingerprint: str
+    reduction: ReductionResult
+    scrubbed: Document | None
+    transmit_safe: bool
+    reasons: list[str] = field(default_factory=list)
+    metrics: dict[str, float] = field(default_factory=dict)
+
+
+def prepare_submission(doc: Document, oracle: Oracle) -> Submission:
+    """Full ADR-0007 pipeline: reduce → scrub → verify twice.
+
+    ``transmit_safe=False`` means: submit the fingerprint only. The scrubbed
+    document is still returned for LOCAL debugging either way — it just must
+    not leave the machine unless safe.
+    """
+    reduction = reduce_document(doc, oracle)
+    reasons: list[str] = []
+
+    scrubbed = scrub(reduction.minimal)
+    # Verify #1: the failure must survive sanitization (some bugs need exact
+    # dimensions — then the repro is inherently user data and cannot ship).
+    if oracle(scrubbed) != reduction.fingerprint:
+        reasons.append("failure-does-not-survive-scrubbing")
+        return Submission(reduction.fingerprint, reduction, scrubbed, False, reasons)
+
+    # Verify #2: the scrubbed repro must not resemble the original design.
+    metrics = similarity(doc, scrubbed)
+    if (len(scrubbed) > _SMALL_REPRO_FEATURES
+            and metrics["surviving_feature_fraction"] > _MAX_SURVIVING_FRACTION):
+        reasons.append("resembles-original:feature-fraction")
+    if metrics["dimension_overlap"] > _MAX_DIM_OVERLAP:
+        reasons.append("resembles-original:dimension-overlap")
+
+    return Submission(reduction.fingerprint, reduction, scrubbed,
+                      transmit_safe=not reasons, reasons=reasons, metrics=metrics)