@ricsam/r5d-worker 0.0.162 → 0.0.164

package/dist/types/runtime/workspace/outer.d.ts

@@ -0,0 +1,105 @@
+import { WorkspaceError } from "./contracts";
+/** The outer repository synchronizes the files of the whole workspace root. Each
+ * project checkout beneath it remains an independent inner repository with its
+ * own GitHub origin; the outer repository never touches inner history. Its Git
+ * directory is authority-owned and lives outside the workspace, so no shell can
+ * edit its configuration or see it as a repository. */
+export declare const OUTER_BRANCH = "main";
+export declare const OUTER_REF = "refs/heads/main";
+export declare const OUTER_SNAPSHOT_LIMIT_BYTES: number;
+/** A whole-workspace walk hashes every changed file; the default 30 s Git budget
+ * is sized for one project. */
+export declare const OUTER_GIT_TIMEOUT_MS: number;
+export declare const OUTER_CONFLICT_CODE = "sync_conflict";
+/** The bootstrap tree a legacy account repository carries. It is never
+ * materialized: the workspace root is the user's, not a README's. */
+export declare const LEGACY_ACCOUNT_README = "# Account workspace\n";
+/** Written to the authority-owned info/exclude. Session artifacts and their
+ * upload staging are blob-synced, secret material never leaves the host, and the
+ * platform's own state directories are not source. Everything else, including a
+ * project's dependency tree, is governed by that project's own ignore files. */
+export declare const OUTER_EXCLUDES: string[];
+export type InnerCheckout = {
+    /** Work-tree-relative POSIX path of the checkout, without a trailing slash. */
+    root: string;
+    /** Paths, relative to the checkout, that its HEAD tracks. Resolved lazily
+     * because only a checkout with new unexplained content needs it. */
+    tracked: () => Promise<ReadonlySet<string>>;
+};
+export type OuterSnapshot = {
+    tree: string;
+    /** Bytes of content that no inner repository explains. */
+    unexplainedBytes: number;
+    unexplainedPaths: string[];
+};
+export type OuterMerge = {
+    tree: string;
+    conflicts: string[];
+};
+export type OuterTreeEntry = {
+    file: string;
+    mode: string;
+    oid: string;
+};
+/** A refusal that names the paths responsible, for the incident evidence. */
+export declare class OuterSnapshotRefusal extends WorkspaceError {
+    readonly paths: string[];
+    constructor(code: string, message: string, paths: string[]);
+}
+export declare class OuterRepository {
+    readonly gitDir: string;
+    readonly workTree: string;
+    private constructor();
+    static open(gitDir: string, workTree: string): Promise<OuterRepository>;
+    private run;
+    private result;
+    head(): Promise<string | null>;
+    setHead(commit: string): Promise<void>;
+    has(object: string): Promise<boolean>;
+    treeOf(commit: string): Promise<string>;
+    emptyTree(): Promise<string>;
+    isAncestor(ancestor: string, descendant: string): Promise<boolean>;
+    listTree(tree: string): Promise<OuterTreeEntry[]>;
+    /** Git refuses to walk into a nested repository until the outer index holds
+     * at least one path beneath it. That entry is written directly, bypassing the
+     * walk; afterwards the checkout is an ordinary directory to every command. A
+     * checkout whose tracked count drops to zero silently disappears again, so
+     * this runs before every snapshot rather than once. */
+    seed(inners: readonly InnerCheckout[]): Promise<void>;
+    private seedCandidate;
+    /** Stage the whole workspace and measure what no inner repository explains.
+     * Inside a checkout, a path its HEAD tracks was asked for by whoever imported
+     * or committed it and costs nothing; a path it ignores never reaches the walk.
+     * Everything else, and everything outside every checkout, counts in full. */
+    snapshot(inners: readonly InnerCheckout[], options?: {
+        allowLargeDiff?: boolean;
+        limitBytes?: number;
+    }): Promise<OuterSnapshot>;
+    /** Staging records a symlink as a link entry, and a nested repository that
+     * appeared between the walk and the add as a gitlink. Neither can be
+     * materialized on another host; both are dropped from the index without
+     * touching the working tree. */
+    private stripUnsupported;
+    commit(tree: string, parents: readonly string[], message: string): Promise<string>;
+    /** A three-way merge computed entirely in the object store. The result tree
+     * of a conflicted merge carries ordinary conflict markers in the files named. */
+    merge(ours: string, theirs: string): Promise<OuterMerge>;
+    /** Move the working tree from one tree to another without clobbering anything
+     * edited since the index last saw it. Git refuses the whole update when any
+     * path it would change is locally modified, so a refusal is transient by
+     * construction: the next snapshot picks that edit up and the merge recurs. */
+    apply(fromTree: string, toTree: string): Promise<void>;
+    /** Materialize a commit into a working tree that holds none of its paths yet. */
+    checkout(commit: string): Promise<void>;
+    /** Reset index and working tree to a commit, deleting tracked paths it lacks.
+     * Never `clean`: the second `-f` that would reach nested repositories is the
+     * one switch this repository must never pass. */
+    reset(commit: string): Promise<void>;
+    diffPaths(fromTree: string, toTree: string): Promise<string[]>;
+    /** Objects reachable from the head that the mirror lacks. The bundle names the
+     * branch, which the storage side verifies before it accepts the head. */
+    bundle(exclude: string | null): Promise<Buffer>;
+    unbundle(bytes: Buffer): Promise<void>;
+    /** Whether a commit's tree is exactly the legacy account bootstrap. */
+    isLegacyBootstrap(commit: string): Promise<boolean>;
+}

package/dist/types/runtime/workspace/storage-wire.d.ts

@@ -6,7 +6,7 @@ export declare const STORAGE_LIMITS: {
     readonly chunkBytes: number;
     readonly blobBytes: number;
     readonly requestBytes: number;
-    readonly treeEntries: 10000;
+    readonly treeEntries: 200000;
 };
 export declare const StorageId: z.ZodString;
 export declare const GitOid: z.ZodString;
@@ -88,6 +88,7 @@ export declare const StorageRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     expectedHead: z.ZodNullable<z.ZodString>;
     commit: z.ZodString;
     bundleId: z.ZodString;
+    force: z.ZodOptional<z.ZodBoolean>;
     operationId: z.ZodString;
     fence: z.ZodObject<{
         installationId: z.ZodString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.162",
+  "version": "0.0.164",
   "type": "module",
   "main": "./dist/mjs/main.mjs",
   "module": "./dist/mjs/main.mjs",
@@ -21,7 +21,7 @@
     "r5d-worker": "dist/mjs/main.mjs"
   },
   "dependencies": {
-    "@ricsam/r5d-api": "^0.0.162",
+    "@ricsam/r5d-api": "^0.0.164",
     "node-pty": "1.1.0",
     "zod": "^4.1.13",
     "picomatch": "^4.0.3"