@mh-gg/git 0.1.1-alpha.20260626T104441232Z

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matterhorn contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# @mh-gg/git
+
+Matterhorn Git transport, encrypted chunk filter, and local CAS utilities.
+
+This package adds two CLI entry points:
+
+- `matterhorn-git` for origins, required Git filters, local epoch keys, encrypted chunk/CAS operations, signing profiles, and outbox inspection.
+- `git-remote-matterhorn` for Git's remote-helper protocol. Git invokes it for origins using the `matterhorn::...` custom transport.
+
+## Native origin
+
+Preferred Git-safe origin format:
+
+```bash
+git remote add origin 'matterhorn::matterhorn+my-room+alice/my-repo;backend=http%3A%2F%2F127.0.0.1%3A43741'
+```
+
+The CLI prints that form by default:
+
+```bash
+matterhorn-git origin my-room my-repo --signing alice --backend http://127.0.0.1:43741
+```
+
+The older canonical form is still accepted:
+
+```text
+matterhorn::room=my-room;repo=my-repo;signing=alice;backend=http%3A%2F%2F127.0.0.1%3A43741
+```
+
+## Encrypted chunk filter
+
+Configure Git's required clean/smudge filter and optionally append a `.gitattributes` rule:
+
+```bash
+matterhorn-git install-filter 'matterhorn::matterhorn+my-room+alice/my-repo' --pattern 'secrets/**'
+```
+
+The filter path is:
+
+```text
+plaintext file
+  -> fastcdc-js content-defined chunks
+  -> per-epoch keyed chunk IDs
+  -> XChaCha20-Poly1305 chunk objects with explicit AAD
+  -> encrypted manifest object
+  -> deterministic Git pointer
+```
+
+Git stores only pointer files for matched paths. The encrypted manifest and chunk objects live under `.git/matterhorn/cas/<room--repo--signing>`. Smudge restores plaintext from that local CAS.
+
+Useful commands:
+
+```bash
+matterhorn-git key init 'matterhorn::matterhorn+my-room+alice/my-repo'
+matterhorn-git key export 'matterhorn::matterhorn+my-room+alice/my-repo'
+matterhorn-git key import 'matterhorn::matterhorn+my-room+bob/my-repo' '<epoch-root-base64url>'
+matterhorn-git chunk secrets/plan.md --origin 'matterhorn::matterhorn+my-room+alice/my-repo' > /tmp/plan.pointer
+matterhorn-git restore /tmp/plan.pointer --origin 'matterhorn::matterhorn+my-room+alice/my-repo' --output /tmp/plan.md
+matterhorn-git publish-cas /tmp/plan.pointer --origin 'matterhorn::matterhorn+my-room+alice/my-repo'
+```
+
+Production key distribution should wrap fresh independent epoch roots to authorized Matterhorn devices. The local `key export/import` commands are for development and controlled demos.
+
+## Push behavior
+
+`git-remote-matterhorn` bridges Git upload-pack/receive-pack to a local bare mirror. After `git-receive-pack` succeeds, it scans pushed trees for Matterhorn Git pointers, verifies the matching encrypted manifest/chunk metadata exists in the local CAS, uploads encrypted object envelopes to `/matterhorn/git/object` when a backend URL is configured; otherwise it stages them for object-plane upload. It then publishes:
+
+```text
+git.manifest.publish
+git.chunk.advertise
+git.ref.update
+```
+
+When no backend URL is configured, operations are queued under `.git/matterhorn/outbox`. With a backend URL, operations are posted to `/matterhorn/operation`.
+
+## Security profile
+
+The implemented v1 profile is `dedup-same-epoch/encrypted-manifest/no-padding`:
+
+- Each epoch uses a fresh independent epoch root.
+- Chunk IDs, manifest IDs, and encryption keys derive from the current epoch root.
+- Deduplication is scoped to one epoch, so post-rotation writes do not reuse old-key ciphertext.
+- Git pointers are deterministic only within the same repo, epoch, chunker params, and plaintext sequence.
+- XChaCha20-Poly1305 uses 24-byte random nonces; AAD binds repo, epoch, kind, algorithm version, and chunk/manifest identity.
+
+V1 protects chunk content from the Git host/object store. It does not claim strong metadata privacy: filenames, commit graph, pointer churn, object sizes, chunk counts, equality of same-epoch deduped chunks, and access patterns may leak unless you add padding, batching, and stricter object-plane privacy.

package/bin/git-remote-matterhorn.cjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const { runRemoteHelper } = require("../src/remoteHelper.cjs");
+
+runRemoteHelper(process.argv.slice(2)).catch((error) => {
+  console.error(`[matterhorn-git] ${error?.stack || error?.message || error}`);
+  process.exit(1);
+});

package/bin/matterhorn-git.cjs

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const {
+  configuredOrigin,
+  createDevSigningProfile,
+  encryptBufferToCas,
+  epochRootFileFor,
+  exportEpochRoot,
+  formatCompactMatterhornOrigin,
+  formatFriendlyOrigin,
+  formatMatterhornOrigin,
+  importEpochRoot,
+  isMatterhornPointer,
+  listOutbox,
+  loadOrCreateEpochRoot,
+  parseMatterhornOrigin,
+  publishPointerMetadata,
+  restorePointerFromCas
+} = require("../src/index.cjs");
+
+function usage() {
+  console.log(`matterhorn-git
+
+Commands:
+  origin <room> <repo> --signing <profile> [--backend <url>] [--canonical|--friendly]
+      Print a Git remote URL. Default is the compact Git-safe form:
+      matterhorn::matterhorn+<room>+<userSigning>/<repo>
+
+  remote-add <name> <room> <repo> --signing <profile> [--backend <url>]
+      Run git remote add <name> <matterhorn-url>.
+
+  install-filter <matterhorn-origin> [--pattern <glob>]
+      Configure Git clean/smudge filters for encrypted chunk pointers.
+      Use --pattern to append a .gitattributes rule for paths you want encrypted.
+
+  filter-clean [--origin <matterhorn-origin>] [--epoch <n>]
+      Git clean filter: plaintext stdin -> Matterhorn encrypted chunk pointer stdout.
+
+  filter-smudge [--origin <matterhorn-origin>]
+      Git smudge filter: pointer stdin -> plaintext stdout using local CAS.
+
+  chunk <file> --origin <matterhorn-origin> [--epoch <n>]
+      Encrypt/chunk one file into the local CAS and print the pointer.
+
+  restore <pointer-file> --origin <matterhorn-origin> [--output <file>]
+      Restore a pointer from the local CAS.
+
+  publish-cas <pointer-file> --origin <matterhorn-origin>
+      Queue/post git.manifest.publish and git.chunk.advertise for a pointer.
+
+  key init|export|import <matterhorn-origin> [secret] [--epoch <n>]
+      Manage local epoch roots. Production should import keys wrapped by Matterhorn.
+
+  profile init <profile> --member <memberId> [--display-name <name>] [--role member|moderator|admin]
+      Create a development signing profile for the helper.
+
+  outbox <matterhorn-origin-url>
+      List queued Matterhorn control-plane operations.
+
+Examples:
+  matterhorn-git origin design-room main --signing alice
+  git remote add origin 'matterhorn::matterhorn+design-room+alice/main'
+  matterhorn-git install-filter 'matterhorn::matterhorn+design-room+alice/main' --pattern 'secrets/**'
+  echo '*.secret filter=matterhorn-crypt diff=matterhorn-crypt merge=matterhorn-crypt -text' >> .gitattributes
+`);
+}
+
+function parseFlags(argv) {
+  const flags = {};
+  const args = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      args.push(arg);
+      continue;
+    }
+    const key = arg.slice(2).replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) flags[key] = true;
+    else {
+      flags[key] = next;
+      i += 1;
+    }
+  }
+  return { args, flags };
+}
+
+function runGit(args) {
+  const result = spawnSync("git", args, { stdio: "inherit", windowsHide: true });
+  if (result.status !== 0) process.exit(result.status || 1);
+}
+
+function runGitCapture(args) {
+  const result = spawnSync("git", args, { encoding: "utf8", stdio: "pipe", windowsHide: true });
+  if (result.status !== 0) throw new Error((result.stderr || result.stdout || `git ${args.join(" ")} failed`).trim());
+  return result.stdout.trim();
+}
+
+function readStdinBuffer() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    process.stdin.on("error", reject);
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks)));
+  });
+}
+
+function originFromFlags(flags, fallback) {
+  return parseMatterhornOrigin(flags.origin || flags.matterhornOrigin || fallback || configuredOrigin());
+}
+
+function appendAttribute(pattern) {
+  if (!pattern) return undefined;
+  const file = path.resolve(process.cwd(), ".gitattributes");
+  const line = `${pattern} filter=matterhorn-crypt diff=matterhorn-crypt merge=matterhorn-crypt -text`;
+  const current = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+  if (!current.split(/\r?\n/).some((existing) => existing.trim() === line)) fs.appendFileSync(file, `${current.endsWith("\n") || !current ? "" : "\n"}${line}\n`);
+  return file;
+}
+
+async function filterClean(flags) {
+  const origin = originFromFlags(flags);
+  const input = await readStdinBuffer();
+  if (isMatterhornPointer(input.toString("utf8"))) {
+    process.stdout.write(input);
+    return;
+  }
+  const result = encryptBufferToCas(input, origin, { epoch: flags.epoch ? Number(flags.epoch) : undefined });
+  process.stdout.write(result.pointer);
+}
+
+async function filterSmudge(flags) {
+  const origin = originFromFlags(flags);
+  const input = await readStdinBuffer();
+  const text = input.toString("utf8");
+  if (!isMatterhornPointer(text)) {
+    process.stdout.write(input);
+    return;
+  }
+  const clear = restorePointerFromCas(text, origin);
+  process.stdout.write(clear);
+}
+
+function originForArgs(args, flags) {
+  return { room: args[0], repo: args[1], signing: flags.signing || flags.userSigning || "default", backend: flags.backend, relay: flags.relay };
+}
+
+async function commandOrigin(argv) {
+  const { args, flags } = parseFlags(argv);
+  const origin = originForArgs(args, flags);
+  if (flags.canonical) console.log(formatMatterhornOrigin(origin));
+  else if (flags.friendly) console.log(formatFriendlyOrigin(origin));
+  else console.log(formatCompactMatterhornOrigin(origin));
+}
+
+async function commandRemoteAdd(argv) {
+  const { args, flags } = parseFlags(argv);
+  const name = args[0] || "origin";
+  const origin = { room: args[1], repo: args[2], signing: flags.signing || flags.userSigning || "default", backend: flags.backend, relay: flags.relay };
+  runGit(["remote", "add", name, flags.canonical ? formatMatterhornOrigin(origin) : formatCompactMatterhornOrigin(origin)]);
+}
+
+async function commandInstallFilter(argv) {
+  const { args, flags } = parseFlags(argv);
+  const origin = parseMatterhornOrigin(args[0] || flags.origin || configuredOrigin());
+  const originUrl = formatCompactMatterhornOrigin(origin);
+  runGit(["config", "matterhorn.origin", originUrl]);
+  runGit(["config", "filter.matterhorn-crypt.clean", "matterhorn-git filter-clean"]);
+  runGit(["config", "filter.matterhorn-crypt.smudge", "matterhorn-git filter-smudge"]);
+  runGit(["config", "filter.matterhorn-crypt.required", "true"]);
+  runGit(["config", "diff.matterhorn-crypt.textconv", "matterhorn-git filter-smudge"]);
+  const attributes = flags.pattern ? appendAttribute(flags.pattern) : undefined;
+  console.log(`Configured matterhorn-crypt filter for ${originUrl}`);
+  if (attributes) console.log(`Updated ${attributes}`);
+}
+
+async function commandFilterClean(argv) {
+  const { flags } = parseFlags(argv);
+  await filterClean(flags);
+}
+
+async function commandFilterSmudge(argv) {
+  const { flags } = parseFlags(argv);
+  await filterSmudge(flags);
+}
+
+async function commandChunk(argv) {
+  const { args, flags } = parseFlags(argv);
+  const file = args[0];
+  if (!file) throw new Error("chunk requires a file path");
+  const origin = originFromFlags(flags);
+  const result = encryptBufferToCas(fs.readFileSync(file), origin, { epoch: flags.epoch ? Number(flags.epoch) : undefined });
+  process.stdout.write(result.pointer);
+}
+
+async function commandRestore(argv) {
+  const { args, flags } = parseFlags(argv);
+  const file = args[0];
+  if (!file) throw new Error("restore requires a pointer file path");
+  const origin = originFromFlags(flags);
+  const clear = restorePointerFromCas(fs.readFileSync(file, "utf8"), origin);
+  if (flags.output) fs.writeFileSync(flags.output, clear);
+  else process.stdout.write(clear);
+}
+
+async function commandPublishCas(argv) {
+  const { args, flags } = parseFlags(argv);
+  const file = args[0];
+  if (!file) throw new Error("publish-cas requires a pointer file path");
+  const result = await publishPointerMetadata(originFromFlags(flags), fs.readFileSync(file, "utf8"), {});
+  for (const item of result.results) {
+    if (item.kind === "objects") console.log(`staged objects ${item.dir}`);
+    else console.log(`${item.draft.type} ${item.result.mode}${item.result.file ? ` ${item.result.file}` : ""}`);
+  }
+}
+
+async function commandKey(argv) {
+  const sub = argv[0];
+  const { args, flags } = parseFlags(argv.slice(1));
+  const origin = parseMatterhornOrigin(args[0] || flags.origin || configuredOrigin());
+  const epoch = Number(flags.epoch || 1);
+  if (sub === "init") {
+    const key = loadOrCreateEpochRoot(origin, epoch, { create: true });
+    console.log(`${epochRootFileFor(origin, epoch)}\t${key.length} bytes`);
+    return;
+  }
+  if (sub === "export") {
+    console.log(exportEpochRoot(origin, epoch));
+    return;
+  }
+  if (sub === "import") {
+    const secret = args[1] || flags.secret;
+    if (!secret) throw new Error("key import requires a secret");
+    const imported = importEpochRoot(origin, epoch, secret);
+    console.log(`Imported epoch ${imported.epoch} key to ${imported.file}`);
+    return;
+  }
+  throw new Error("key command must be init, export, or import");
+}
+
+async function commandProfile(argv) {
+  if (argv[0] !== "init") throw new Error("profile command must be init");
+  const { args, flags } = parseFlags(argv.slice(1));
+  const profile = args[0] || flags.profile || "default";
+  const created = createDevSigningProfile(profile, {
+    memberId: flags.member || flags.memberId || profile,
+    displayName: flags.displayName || flags.name,
+    role: flags.role || "member"
+  }, { repo: flags.repo === true });
+  console.log(`Created ${created.file}`);
+}
+
+async function commandOutbox(argv) {
+  const files = listOutbox(parseMatterhornOrigin(argv[0] || configuredOrigin()));
+  for (const file of files) {
+    const draft = JSON.parse(fs.readFileSync(file, "utf8"));
+    console.log(`${file}\t${draft.type}\t${draft.payload?.repoId || ""}\t${draft.payload?.ref || draft.payload?.manifestId || ""}`);
+  }
+}
+
+async function commandGitConfigOrigin() {
+  console.log(runGitCapture(["config", "--get", "matterhorn.origin"]));
+}
+
+const COMMAND_HANDLERS = {
+  origin: commandOrigin,
+  "remote-add": commandRemoteAdd,
+  "install-filter": commandInstallFilter,
+  "filter-clean": commandFilterClean,
+  "filter-smudge": commandFilterSmudge,
+  chunk: commandChunk,
+  restore: commandRestore,
+  "publish-cas": commandPublishCas,
+  key: commandKey,
+  profile: commandProfile,
+  outbox: commandOutbox,
+  "git-config-origin": commandGitConfigOrigin
+};
+
+async function main(argv) {
+  const command = argv[0];
+  if (!command || command === "help" || command === "--help" || command === "-h") return usage();
+  const handler = COMMAND_HANDLERS[command];
+  if (!handler) {
+    usage();
+    process.exitCode = 1;
+    return;
+  }
+  await handler(argv.slice(1));
+}
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(error?.stack || error?.message || error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@mh-gg/git",
+  "version": "0.1.1-alpha.20260626T104441232Z",
+  "description": "Matterhorn Git helper, origin transport bridge, and shared Git manifest utilities.",
+  "type": "commonjs",
+  "main": "src/index.cjs",
+  "exports": {
+    ".": "./src/index.cjs",
+    "./origin": "./src/originUrl.cjs",
+    "./remote-helper": "./src/remoteHelper.cjs",
+    "./cas": "./src/cas.cjs",
+    "./chunker": "./src/chunker.cjs",
+    "./crypto": "./src/crypto.cjs"
+  },
+  "bin": {
+    "matterhorn-git": "./bin/matterhorn-git.cjs",
+    "git-remote-matterhorn": "./bin/git-remote-matterhorn.cjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "package.json"
+  ],
+  "dependencies": {
+    "@mh-gg/event": "^0.1.1-alpha.20260626T104441232Z",
+    "@mh-gg/protocol": "^0.1.1-alpha.20260626T104441232Z",
+    "@mh-gg/host-runtime": "^0.1.1-alpha.20260626T104441232Z"
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "node --test test/*.test.cjs",
+    "coverage": "node --test --experimental-test-coverage --test-coverage-lines=80 --test-coverage-functions=80 --test-coverage-branches=60 --test-coverage-include=src/**/*.cjs test/*.test.cjs"
+  }
+}

package/src/cas/pointer.cjs

@@ -0,0 +1,121 @@
+const path = require("node:path");
+const fs = require("node:fs");
+const { parsePointer } = require("./manifest.cjs");
+const { parseMatterhornOrigin } = require("./originUrl.cjs");
+const {
+  objectPathFor,
+  manifestPathFor,
+  casRootFor,
+  readCasIndex,
+  readJson,
+  fileExists,
+  writePrivateJson,
+  safeId,
+  ensurePrivateDir,
+  decryptManifestEnvelope,
+  decryptChunkEnvelope
+} = require("./cas/storage.cjs");
+
+const POINTER_VERSION = "https://matterhorn.gg/git-chunks/v1";
+
+function isMatterhornPointer(text) {
+  return String(text || "").startsWith(`version ${POINTER_VERSION}\n`);
+}
+
+function manifestEnvelopeForPointer(pointerInput, originInput, options = {}) {
+  const pointer = typeof pointerInput === "string" ? parsePointer(pointerInput) : pointerInput;
+  const index = readCasIndex(originInput, options);
+  const manifest = index.manifests?.[pointer.manifestId];
+  if (!manifest) throw new Error(`Manifest ${pointer.manifestId} is not present in the local Matterhorn Git CAS`);
+  const objectId = manifest.objectId;
+  const file = manifestPathFor(originInput, objectId, options);
+  const envelope = readJson(file, null);
+  if (!envelope) throw new Error(`Encrypted manifest object ${objectId} is missing`);
+  return envelope;
+}
+
+function restorePointerFromCas(pointerText, originInput, options = {}) {
+  const pointer = parsePointer(pointerText);
+  const origin = parseMatterhornOrigin(originInput, { repo: pointer.repoId });
+  if (origin.repo !== pointer.repoId) throw new Error(`Pointer repo ${pointer.repoId} does not match origin repo ${origin.repo}`);
+  const manifestEnvelope = manifestEnvelopeForPointer(pointer, origin, options);
+  const manifest = decryptManifestEnvelope(manifestEnvelope, origin, options);
+  const parts = [];
+  for (const chunk of manifest.chunks || []) {
+    const objectId = chunk.objectCandidates?.[0];
+    if (!objectId) throw new Error(`Chunk ${chunk.index} has no object candidate`);
+    const file = objectPathFor(origin, objectId, options);
+    const envelope = readJson(file, null);
+    if (!envelope) throw new Error(`Encrypted chunk object ${objectId} is missing`);
+    const clear = decryptChunkEnvelope(envelope, origin, options);
+    if (clear.length !== Number(chunk.clearLen)) throw new Error(`Chunk ${chunk.index} length mismatch`);
+    parts.push(clear);
+  }
+  const restored = Buffer.concat(parts);
+  if (Number.isFinite(Number(manifest.file?.clearSize)) && restored.length !== Number(manifest.file.clearSize)) throw new Error("Restored file length mismatch");
+  return restored;
+}
+
+function metadataForPointer(pointerText, originInput, options = {}) {
+  const pointer = typeof pointerText === "string" ? parsePointer(pointerText) : pointerText;
+  const index = readCasIndex(originInput, options);
+  const manifest = index.manifests?.[pointer.manifestId];
+  if (!manifest) throw new Error(`Manifest ${pointer.manifestId} is not present in the local Matterhorn Git CAS`);
+  const chunks = [];
+  for (const chunk of manifest.chunks || []) {
+    const objectId = chunk.objectCandidates?.[0];
+    const object = objectId ? index.objects?.[objectId] : undefined;
+    chunks.push({
+      chunkPlainId: chunk.chunkPlainId,
+      objectId,
+      epoch: pointer.epoch,
+      clearLen: chunk.clearLen,
+      storedLen: object?.storedLen
+    });
+  }
+  return {
+    repoId: pointer.repoId,
+    epoch: pointer.epoch,
+    manifestId: pointer.manifestId,
+    objectId: manifest.objectId,
+    clearSize: manifest.clearSize,
+    chunkCount: manifest.chunkCount,
+    pointerProfile: pointer.profile,
+    chunks
+  };
+}
+
+function materializeCasObjectOutbox(originInput, pointerText, options = {}) {
+  const origin = parseMatterhornOrigin(originInput);
+  const pointer = parsePointer(pointerText);
+  const metadata = metadataForPointer(pointer, origin, options);
+  const root = path.join(casRootFor(origin, options), "object-outbox", safeId(pointer.manifestId));
+  ensurePrivateDir(root);
+  const manifestEnvelope = manifestEnvelopeForPointer(pointer, origin, options);
+  const manifestFile = path.join(root, `${safeId(metadata.objectId)}.json`);
+  writePrivateJson(manifestFile, manifestEnvelope);
+  const files = [manifestFile];
+  for (const chunk of metadata.chunks) {
+    const source = objectPathFor(origin, chunk.objectId, options);
+    const target = path.join(root, `${safeId(chunk.objectId)}.json`);
+    try {
+      fs.copyFileSync(source, target);
+    } catch (error) {
+      if (error && (error.code === "ENOENT" || error.code === "ENOTDIR")) continue;
+      throw error;
+    }
+    try { fs.chmodSync(target, 0o600); } catch (matterhornIgnoredError) {
+      globalThis.__matterhornIgnoredError?.(matterhornIgnoredError, "packages/matterhorn-git/src/cas/pointer.cjs");
+    }
+    files.push(target);
+  }
+  return { dir: root, files, metadata };
+}
+
+module.exports = {
+  isMatterhornPointer,
+  manifestEnvelopeForPointer,
+  metadataForPointer,
+  restorePointerFromCas,
+  materializeCasObjectOutbox
+};