@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/types/working-tree-mirror.d.ts

@@ -1,424 +0,0 @@
-import fs from "node:fs";
-import { type AtomicRenamePrimitives } from "./atomic-rename";
-export type WorkingTreeSourceMode = "all" | "git";
-export type WorkingTreeDeletionMode = "all" | "git";
-export type WorkingTreeMirrorDurability = "per_entry" | "deferred_private_staging";
-export type TreeEntry = {
-    kind: "directory";
-    mode: number;
-} | {
-    kind: "file";
-    mode: number;
-    size: number;
-} | {
-    kind: "symlink";
-    mode: number;
-    target: string;
-}
-/**
- * A submodule (D4): the enclosing repository records a commit at this path
- * and never its contents. A leaf for every operation here: nothing beneath
- * it is inspected, copied, captured, removed, or restored.
- */
- | {
-    kind: "gitlink";
-    objectId: string;
-};
-export type WorkingTreeGitlink = {
-    relativePath: string;
-    objectId: string;
-};
-/** One index record of a Git checkout, in the form `git update-index --index-info` accepts back. */
-export type WorkingTreeIndexRecord = {
-    mode: string;
-    objectId: string;
-    stage: number;
-    relativePath: string;
-};
-/**
- * Index entries a Git-target mirror changes: the records it removes or
- * overwrites (a restore puts them back) and the gitlinks it writes (a restore
- * drops them first).
- */
-export type WorkingTreeIndexChanges = {
-    removed: WorkingTreeIndexRecord[];
-    written: WorkingTreeGitlink[];
-};
-export type WorkingTreeInspectionOptions = {
-    /**
-     * Gitlinks the enclosing repository records under an all-mode root, keyed
-     * by relative path. Git checks a submodule out as an empty directory, so
-     * the filesystem alone cannot show one; the entry replaces whatever is on
-     * disk at that path. Ignored in Git mode, where the index is read directly.
-     */
-    gitlinks?: ReadonlyMap<string, string>;
-    /**
-     * Receives the `lstat` of every inspected entry, keyed by relative path.
-     * Merge hydration compares these against the stats a later mutation finds
-     * on disk, so a write that lands between inspection and mutation is seen.
-     */
-    stats?: Map<string, fs.Stats>;
-};
-/**
- * What a projection read for one source entry: enough of the `lstat` to tell
- * later whether the same path changed since (a rewrite moves ctime, and a
- * rename-over changes the inode), or the symlink target, or the gitlink
- * pointer. Recorded by the projection mirror and by merge projection and
- * consumed by merge hydration.
- */
-export type ProjectedWorkingTreeEntry = {
-    kind: "file";
-    size: number;
-    mode: number;
-    mtimeMs: number;
-    ctimeMs: number;
-    ino: number;
-} | {
-    kind: "symlink";
-    target: string;
-} | {
-    kind: "gitlink";
-    objectId: string;
-};
-/** The stat fields a projection records, from an `lstat` or `fstat` of a regular file. */
-export declare function projectedFileEntry(stat: fs.Stats): Extract<ProjectedWorkingTreeEntry, {
-    kind: "file";
-}>;
-/** True when a current `lstat` still describes the projected regular file: same inode, size, mode and timestamps. */
-export declare function projectedFileEntryMatches(entry: Extract<ProjectedWorkingTreeEntry, {
-    kind: "file";
-}>, stat: fs.Stats): boolean;
-/** True when two `lstat` results describe the same unchanged entry (kind, inode, size, mode, timestamps). */
-export declare function workingTreeStatsMatch(left: fs.Stats, right: fs.Stats): boolean;
-/** True when two `lstat` results name the same inode. */
-export declare function sameWorkingTreeInode(left: fs.Stats, right: fs.Stats): boolean;
-/**
- * True when the entry a switch displaced is the very inode its expectation
- * described, still holding what that expectation saw: same identity, kind,
- * mode, size and mtime. Its ctime is not compared, because the exchange or
- * rename that moved it aside set the ctime itself; the expectation's ctime
- * was already checked immediately before the switch.
- */
-export declare function displacedEntryMatches(expected: fs.Stats, displaced: fs.Stats): boolean;
-/**
- * An entry a guarded pass displaced and kept, by absolute path, with the
- * `lstat` it had the moment it was displaced. It is the exact inode that was
- * at the path (not a copy), so a rollback can put it back without touching
- * its bytes and so a write through a descriptor opened before the switch is
- * still visible on it when the pass settles.
- */
-export type WorkingTreeRetainedEntry = {
-    path: string;
-    stat: fs.Stats;
-    content?: string;
-};
-/**
- * Another writer's entry a guarded pass displaced and could not put back at
- * its path without displacing yet another write: it is kept where it is and
- * reported instead of being removed. `later_writer`: a newer entry took the
- * path while this one was being restored. `reappeared`: while the path was
- * momentarily empty during a fallback replacement, something was created
- * there; the displaced entry is kept because that creator may have meant to
- * modify it. `unrestorable`: no primitive could restore it (a directory on a
- * filesystem without a native no-replace rename).
- */
-export type WorkingTreeRetainedForeignEntry = {
-    relativePath: string;
-    path: string;
-    reason: "later_writer" | "reappeared" | "unrestorable";
-};
-/**
- * Thrown by a guarded mirror when the target entry it is about to replace,
- * remove or create no longer matches the state observed when the mirror was
- * prepared: something else wrote there in between. The caller rolls the
- * mount back through the journal instead of finishing over the writer. When
- * the pass had to keep a displaced writer's entry aside (see
- * `WorkingTreeRetainedForeignEntry`) the error lists it.
- */
-export declare class WorkingTreeTargetChangedError extends Error {
-    readonly relativePath: string;
-    readonly retained: WorkingTreeRetainedForeignEntry[];
-    constructor(relativePath: string, options?: {
-        detail?: string;
-        retained?: WorkingTreeRetainedForeignEntry[];
-    });
-}
-/**
- * One mutation a guarded mirror made, in order. `replaced` is the entry that
- * was there before (null when the path was created) and `after` the `lstat`
- * of the entry the mirror left behind (null when it removed the path); it is
- * the mirror's own entry, identified by inode, never a later writer's.
- * `displaced` is the replaced or removed entry itself, retained until the
- * pass settles or its rollback finishes. A rollback undoes an entry only
- * while the path still shows `after`; anything else means another writer
- * came later and keeps what it wrote.
- */
-export type WorkingTreeMirrorJournalEntry = {
-    relativePath: string;
-    replaced: TreeEntry | null;
-    after: fs.Stats | null;
-    /** Immutable bytes owned by the pass, never inferred from the visible path after publication. */
-    afterContent?: string;
-    displaced?: WorkingTreeRetainedEntry;
-};
-export type WorkingTreeMirrorJournal = {
-    entries: WorkingTreeMirrorJournalEntry[];
-    /** The Git index changes the pass applied (its last step); a rollback puts them back. */
-    indexApplied?: WorkingTreeIndexChanges;
-    /** Writers' entries the pass or its rollback displaced and kept aside; never removed by the mirror. */
-    retained?: WorkingTreeRetainedForeignEntry[];
-};
-/** Content a guarded mirror writes at a path instead of copying the source entry (a merged file). */
-export type WorkingTreeMirrorOverride = {
-    content: Buffer;
-    mode: number;
-};
-export type WorkingTreeMirrorGuards = {
-    /**
-     * The target `lstat` each path must still show immediately before it is
-     * mutated (null: the path must still be absent). Paths not listed are
-     * switched against whatever they hold at that moment. A mismatch throws
-     * WorkingTreeTargetChangedError before anything is written at that path.
-     * The pass updates an entry once it has satisfied it (a removal it made
-     * itself leaves the path expected absent), so a path mutated in two steps
-     * is checked against the pass's own intermediate state.
-     */
-    expectations?: Map<string, fs.Stats | null>;
-    /** Known pre-hydration Git blob IDs, when the merge decision already read the bytes. */
-    preBlobs?: ReadonlyMap<string, string>;
-    /** Merged bytes written in place of the source entry's bytes. */
-    overrides?: ReadonlyMap<string, WorkingTreeMirrorOverride>;
-    /** Every mutation is appended here for `rollbackWorkingTreeMirrorJournal`. */
-    journal?: WorkingTreeMirrorJournal;
-};
-/**
- * Points in a guarded pass at which another writer could interleave, exposed
- * so tests can place a deterministic write there. `before_switch` and
- * `before_remove` fire after the path's expectation was verified and
- * immediately before the exchange, rename or unlink; `after_switch` and
- * `after_remove` immediately after it, before the displaced entry is
- * inspected; `before_yield` before a mismatched displaced entry is put back;
- * `before_settle` before the pass re-inspects its retained entries; the
- * rollback variants bracket the rollback's own switches. Never set in
- * production.
- */
-export type WorkingTreeMirrorRacePhase = "before_switch" | "after_switch" | "before_yield" | "before_remove" | "after_remove" | "before_settle" | "before_rollback_switch" | "before_rollback_remove";
-export type WorkingTreeMirrorRaceEvent = {
-    phase: WorkingTreeMirrorRacePhase;
-    relativePath: string;
-    targetPath: string;
-};
-/** Test seam for deterministic race regressions; pass null to clear. */
-export declare function setWorkingTreeMirrorRaceHook(hook: ((event: WorkingTreeMirrorRaceEvent) => void) | null): void;
-/**
- * Destructive native-tree moves cannot silently apply the Git-target filter:
- * doing so would delete legitimate case-sensitive POSIX filenames after the
- * filtered copy. Exact native `.git` metadata is intentionally disposable;
- * every portable alias must be remediated before the old tree is retired.
- */
-export declare function assertWorkingTreeHasNoPortableGitMetadataAliases(root: string): void;
-type RelativePathInspection = {
-    kind: "entry";
-    absolutePath: string;
-    stat: fs.Stats;
-} | {
-    kind: "missing";
-} | {
-    kind: "blocked";
-    blockingPath: string;
-};
-export type WorkingTreePathInspection = RelativePathInspection;
-/** `lstat` a target-relative path without following any ancestor symlink; see the mirror's own traversal rules. */
-export declare function inspectWorkingTreePath(root: string, relativePath: string): WorkingTreePathInspection;
-export declare function inspectWorkingTree(root: string, mode: WorkingTreeSourceMode, options?: WorkingTreeInspectionOptions): Map<string, TreeEntry>;
-/** The primitives a guarded pass or rollback on `targetRoot` would use, after probing its filesystem. */
-export declare function workingTreeAtomicRenameSupport(targetRoot: string): AtomicRenamePrimitives["support"];
-/**
- * Where a guarded pass on `targetRoot` keeps staged and displaced entries.
- * Entries left there after a crash are evidence for recovery: each name ends
- * with the percent-encoded target-relative path of the entry it held.
- */
-export declare function workingTreeDisplacedRetentionDirectory(targetRoot: string): string | null;
-type MirrorTarget = {
-    existing: Map<string, TreeEntry>;
-    /** Present for Git targets: their index and the submodule directories a mirror must leave alone. */
-    git: {
-        indexRecords: WorkingTreeIndexRecord[];
-        submodules: Map<string, string | null>;
-        /** Submodule directories that hold anything at all; never removed, and their index entries stay. */
-        occupied: Set<string>;
-    } | null;
-};
-export type WorkingTreeMirrorInput = {
-    sourceRoot: string;
-    targetRoot: string;
-    sourceMode: WorkingTreeSourceMode;
-    deletionMode: WorkingTreeDeletionMode;
-    /** Gitlinks the enclosing repository records for an all-mode source (see `inspectWorkingTree`). */
-    sourceGitlinks?: ReadonlyMap<string, string>;
-};
-/**
- * Both trees of a mirror, inspected once. `desired` is every source entry
- * (shielded ones included), `existing` the target's deletion-mode entry set,
- * and `existingStats` the `lstat` of each existing entry as it was seen.
- * Merge hydration decides per path from this and applies through
- * `applyWorkingTreeMirror` with guards that compare against those stats.
- */
-export type PreparedWorkingTreeMirror = {
-    sourceRoot: string;
-    targetRoot: string;
-    deletionMode: WorkingTreeDeletionMode;
-    desired: Map<string, TreeEntry>;
-    existing: Map<string, TreeEntry>;
-    existingStats: Map<string, fs.Stats>;
-    git: MirrorTarget["git"];
-    shielded: Set<string>;
-};
-export declare function prepareWorkingTreeMirror(input: WorkingTreeMirrorInput): PreparedWorkingTreeMirror;
-/**
- * Restrict what an apply pass touches. Without a selection the mirror makes
- * the target equal to the source (every desired path written, every existing
- * path outside the desired set removed). With one, only `write` paths are
- * copied (or replaced by an override), only `remove` paths are removed, and
- * `desiredForIndex` is the tree the Git index is reconciled to; every other
- * path is left exactly as it is. Desired directories are still ensured.
- */
-export type WorkingTreeMirrorSelection = {
-    write: ReadonlySet<string>;
-    remove: ReadonlySet<string>;
-    desiredForIndex: ReadonlyMap<string, TreeEntry>;
-};
-export type WorkingTreeMirrorApplyOptions = {
-    durability?: WorkingTreeMirrorDurability;
-    guards?: WorkingTreeMirrorGuards;
-    selection?: WorkingTreeMirrorSelection;
-    /** Collect the projection record of every copied or verified source entry. */
-    projected?: Map<string, ProjectedWorkingTreeEntry>;
-};
-export declare function applyWorkingTreeMirror(prepared: PreparedWorkingTreeMirror, options?: WorkingTreeMirrorApplyOptions): {
-    paths: string[];
-    gitlinks: WorkingTreeGitlink[];
-};
-export declare function mirrorWorkingTree(input: WorkingTreeMirrorInput & {
-    /**
-     * Defer destination fsync only while building an unpublished private tree.
-     * The caller must durably fsync that complete tree before publishing it or
-     * mutating the source authority.
-     */
-    durability?: WorkingTreeMirrorDurability;
-    /** Collect the projection record of every copied or verified source entry. */
-    projected?: Map<string, ProjectedWorkingTreeEntry>;
-}): {
-    paths: string[];
-    gitlinks: WorkingTreeGitlink[];
-};
-/** Canonical relative form used by mirror plans and scopes, or null when the value is unsafe. */
-export declare function normalizeWorkingTreeRelativePath(value: string): string | null;
-export type WorkingTreeMirrorPlan = {
-    /**
-     * Every target path the mirror creates, rewrites, or verifies, ancestor
-     * directories included. A gitlink is verified as a directory; paths a
-     * submodule directory on the target shields are left out.
-     */
-    desired: Map<string, TreeEntry>;
-    /**
-     * Target entries the mirror removes or overwrites, as they are before it
-     * runs. A directory entry means the whole subtree goes, ignored files
-     * included; entries beneath it are folded into it. Never a gitlink: a
-     * submodule directory stays, and only its index entry can change.
-     */
-    replaced: Map<string, TreeEntry>;
-    /** Desired paths that have no target entry yet. */
-    absent: string[];
-    /** Index entries the mirror changes on a Git target; empty for any other target. */
-    index: WorkingTreeIndexChanges;
-};
-/**
- * Compute exactly which target entries `mirrorWorkingTree` would remove,
- * overwrite, or create for the same input, without changing anything. The
- * removal set is the target's deletion-mode file set minus the desired paths.
- * A desired path replaces its target entry when the kinds differ, a symlink
- * points elsewhere, or a file's bytes or mode differ; an equal entry is left
- * alone, so the plan covers only what the mirror actually touches. A Git
- * target's ignored trees appear only where a desired path lands on them, and
- * its submodule directories only as index changes.
- */
-export declare function planWorkingTreeMirror(input: WorkingTreeMirrorInput): WorkingTreeMirrorPlan;
-/**
- * The plan for an apply pass over `prepared`, optionally restricted to a
- * selection (see `applyWorkingTreeMirror`): with one, only the selected
- * removals and writes count, an override always replaces its target entry,
- * and `desired` lists the selected writes plus the desired directories.
- */
-export declare function planPreparedWorkingTreeMirror(prepared: PreparedWorkingTreeMirror, options?: {
-    selection?: WorkingTreeMirrorSelection;
-    overrides?: ReadonlyMap<string, WorkingTreeMirrorOverride>;
-}): WorkingTreeMirrorPlan;
-/**
- * Undo the mutations a guarded apply pass journaled, in reverse order. A
- * replaced or removed entry the pass still retains (its very inode) is
- * switched back into place; one already released is rebuilt from the
- * snapshot `captureWorkingTreeMirrorPlan` took of the plan's replaced
- * entries. Every restore is itself a guarded switch: an entry is undone only
- * while the path still shows exactly what the mirror left there (or is still
- * absent where the mirror removed it), verified by the switch as it happens;
- * a path that another writer has touched since is left alone and reported in
- * `abandoned`. Directories the mirror created are removed only when empty.
- * Returns the target-relative paths it touched for the durability barrier,
- * and, when there are any, the writer's entries it had to keep aside.
- */
-export declare function rollbackWorkingTreeMirrorJournal(input: {
-    journal: WorkingTreeMirrorJournal;
-    targetRoot: string;
-    snapshotRoot: string;
-}): {
-    paths: string[];
-    abandoned: string[];
-    retained?: WorkingTreeRetainedForeignEntry[];
-};
-export type WorkingTreeMirrorScope = {
-    /** Desired paths that did not exist before the mirror ran; a restore removes them. */
-    absent: string[];
-    /** Directories captured whole; a restore makes them identical to the snapshot again. */
-    trees: string[];
-    /** Index entries the mirror changed on a Git target; a restore drops the written gitlinks and puts the removed records back. */
-    index?: WorkingTreeIndexChanges;
-};
-/**
- * Copy the entries a mirror plan replaces into `snapshotRoot` at their
- * target-relative paths, so that `restoreWorkingTreeMirrorScope` can undo the
- * mirror. Files and symlinks are copied individually and a replaced directory
- * is copied whole; ancestor directories appear only as containers. Returns
- * the scope that must be kept beside the snapshot.
- */
-export declare function captureWorkingTreeMirrorPlan(input: {
-    plan: WorkingTreeMirrorPlan;
-    targetRoot: string;
-    snapshotRoot: string;
-    durability?: WorkingTreeMirrorDurability;
-}): WorkingTreeMirrorScope;
-/**
- * Undo a mirror whose plan was captured with `captureWorkingTreeMirrorPlan`:
- * remove everything the mirror may have created, sweep its interrupted
- * temporary files, and put every captured entry back. Entries the plan did
- * not cover (a Git target's ignored files, for instance) are never read or
- * written. Safe to repeat after a partial run. Returns the target-relative
- * paths it removed or restored, for the caller's durability barrier.
- */
-export declare function restoreWorkingTreeMirrorScope(input: {
-    snapshotRoot: string;
-    targetRoot: string;
-    scope: WorkingTreeMirrorScope;
-}): {
-    paths: string[];
-};
-/**
- * Make the listed target-relative entries durable together with the directory
- * entries that name them: every listed regular file and real directory is
- * fsynced, and so is each listed path's parent directory and the root.
- * Symlinks and missing paths contribute only their parent, which is what
- * records their creation or removal. Ancestors are never followed through
- * symlinks. Nothing outside the listed paths is read.
- */
-export declare function fsyncWorkingTreePaths(root: string, relativePaths: Iterable<string>): void;
-export {};

package/dist/types/workspace-automatic-sync-policy.d.ts

@@ -1,57 +0,0 @@
-type ProjectTarget = {
-    type: "project";
-    projectId: string;
-    branchName: string;
-};
-type WorkspaceTarget = {
-    type: "workspace";
-    rootProfile: "visible_projects" | "canonical_sync";
-};
-type PendingCreatedBranch = {
-    projectId: string;
-    branchName: string;
-};
-export declare const PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS = 120000;
-export type PendingCreatedBranchAutomaticSyncDeferral = {
-    kind: "active_target";
-} | {
-    kind: "creation_grace";
-    retryAfterMs: number;
-};
-export declare function pendingCreatedBranchKey(projectId: string, branchName: string): string;
-export declare function hasActiveVisibleProjectsWorkspaceTarget(activeTargets: Iterable<ProjectTarget | WorkspaceTarget>): boolean;
-export declare function projectBranchHasActiveWorkspaceTarget(projectId: string, branchName: string, activeTargets: Iterable<ProjectTarget | WorkspaceTarget>): boolean;
-/**
- * Activity fence evaluated from inside the workspace mutation gate's exclusive
- * sync lease. Canonical-sync targets are deliberately absent: an immediately
- * reserved follow-up remediation command may already be queued, but the gate
- * proves that it cannot overlap this sync. A credential-bearing process group
- * that survived command teardown is tracked separately and still fails closed.
- */
-export declare function projectBranchMountBusyDuringExclusiveSync(input: {
-    projectId: string;
-    branchName: string;
-    executionDisabled: boolean;
-    worktreeOperationInProgress: boolean;
-    retainedCanonicalProcessGroup: boolean;
-    activeTargets: Iterable<ProjectTarget | WorkspaceTarget>;
-}): boolean;
-/** Fence visible activity and any retained canonical descendant that outlived its command lease. */
-export declare function workspacePlansMountBusyDuringExclusiveSync(activeTargets: Iterable<ProjectTarget | WorkspaceTarget>, retainedCanonicalProcessGroup?: boolean): boolean;
-/**
- * Keep automatic intent pending while an agent process is active on a
- * creator-local branch: the branch's mount would be skipped as busy anyway,
- * and the cycle's subprocess and disk work would only compete with that
- * process's next command. Its terminal trigger (or a later periodic/connect
- * cycle) publishes afterward. (The sync cycle itself now yields the event
- * loop while it runs; this deferral is about not starting pointless work,
- * not about loop starvation.)
- */
-export declare function shouldDeferAutomaticWorkspaceSyncForPendingBranch(pendingCreatedBranches: readonly PendingCreatedBranch[], activeTargets: Iterable<ProjectTarget | WorkspaceTarget>): boolean;
-/**
- * Automatic publication yields briefly after local branch creation so the
- * server can durably record the branch and reserve its first agent process.
- * Explicit/reconnect synchronization does not use this policy.
- */
-export declare function pendingCreatedBranchAutomaticSyncDeferral(pendingCreatedBranches: readonly PendingCreatedBranch[], activeTargets: Iterable<ProjectTarget | WorkspaceTarget>, publicationNotBeforeByBranch: ReadonlyMap<string, number>, nowMs?: number): PendingCreatedBranchAutomaticSyncDeferral | null;
-export {};

package/dist/types/workspace-branch-incarnation-policy.d.ts

@@ -1,14 +0,0 @@
-type BranchIncarnation = {
-    branchId?: string;
-};
-/**
- * Deletion is idempotent only while no same-name state belongs to another
- * durable row. Call this inside the workspace mutation lease, before creating
- * a tombstone or touching a checkout/ref.
- */
-export declare function assertProjectBranchDeletionIncarnation(input: {
-    requiredBranchId: string;
-    configuredBranch?: BranchIncarnation;
-    pendingLocalBranch?: BranchIncarnation;
-}): void;
-export {};

package/dist/types/workspace-command-sync-policy.d.ts

@@ -1,57 +0,0 @@
-export type WorkspaceCommandTarget = {
-    type: "project";
-    projectId: string;
-    branchName: string;
-} | {
-    type: "workspace";
-    rootProfile: "visible_projects" | "canonical_sync";
-};
-type WorkspaceCommandMutationCoordinator = {
-    runMutation<T>(operation: () => Promise<T> | T): Promise<T>;
-    acquireMutation(): Promise<() => void>;
-};
-export type WorkspaceSyncCompletionBarrier = {
-    afterCurrent(): Promise<void>;
-    /**
-     * Null when no workspace filesystem job holds any of the targets' mounts
-     * right now; otherwise a promise that settles once every current holder
-     * released them (rejecting with WorkspaceMountHoldAbortedError when
-     * `signal` aborts first). Workspace targets have no mount and never hold.
-     */
-    mountHold(targets: readonly WorkspaceCommandTarget[], signal?: AbortSignal): Promise<void> | null;
-};
-/**
- * A project command may reserve as soon as no workspace filesystem job holds
- * its mount: per-mount hydration and projection observe busy-ness before they
- * dispatch a job and hold the mount until the job ended, so a reservation
- * taken here is never interleaved with a job reading or writing the mount. A
- * visible-projects workspace command spans every project, so it keeps the
- * whole-cycle barrier. Canonical remediation is serialized separately by the
- * mutation gate. Commands without a workspace effect (incident-9 control
- * commands among them) never come here and never wait.
- *
- * A command may declare several targets (its own checkout plus the sibling
- * checkouts its session claimed). Every listed mount is reserved together:
- * the reservation happens only in a synchronous stretch in which none of
- * them is held, so a claimed mount that is mid-hydration delays the command
- * exactly as its own mount would.
- */
-export declare function reserveWorkspaceCommandAfterCurrentSync(target: WorkspaceCommandTarget | readonly WorkspaceCommandTarget[], coordinator: WorkspaceSyncCompletionBarrier, reserve: () => void, options?: {
-    signal?: AbortSignal;
-}): Promise<void>;
-/**
- * Commands in visible checkouts behave like independent Git clients and may
- * overlap periodic synchronization. Canonical remediation commands mutate the
- * sync checkout itself, so they must remain serialized with synchronization.
- */
-export declare function shouldSerializeWorkspaceCommand(target: WorkspaceCommandTarget): boolean;
-export declare function runWorkspaceCommand<T>(target: WorkspaceCommandTarget, coordinator: WorkspaceCommandMutationCoordinator, operation: () => Promise<T> | T): Promise<T>;
-/**
- * Run a command whose target was reserved before asynchronous preparation.
- * For a serialized canonical command, the reservation must disappear inside
- * the mutation operation: removing it after `runMutation` resolves is too
- * late because releasing the lease can synchronously wake a queued sync.
- */
-export declare function runReservedWorkspaceCommand<T>(target: WorkspaceCommandTarget, coordinator: WorkspaceCommandMutationCoordinator, operation: () => Promise<T> | T, releaseReservation: () => void): Promise<T>;
-export declare function acquireWorkspaceCommandMutation(target: WorkspaceCommandTarget, coordinator: WorkspaceCommandMutationCoordinator): Promise<(() => void) | undefined>;
-export {};

package/dist/types/workspace-command-targets.d.ts

@@ -1,37 +0,0 @@
-/**
- * Declared additional targets of a command, PTY or one-shot exec.
- *
- * A server that forwards a session's live `checkout` claims attaches the
- * claimed sibling checkouts as `additionalTargets`. The worker treats every
- * listed project branch exactly like the command's own target for admission
- * (every mount is reserved and waits on the hold fence), busy detection and
- * mutation tokens, for the whole lifetime of the process: the list is fixed
- * when the command is admitted and only the process exit removes it. The
- * primary target alone keeps environment attribution, the plans-mount
- * predicate and credential-bearing process-group ownership.
- */
-export type WorkspaceCommandProjectTarget = {
-    type: "project";
-    projectId: string;
-    branchName: string;
-};
-export type WorkspaceCommandAnyTarget = WorkspaceCommandProjectTarget | {
-    type: "workspace";
-    ownerUserId: string;
-    rootProfile: "visible_projects" | "canonical_sync";
-};
-export type WorkspaceCommandTargetValidators = {
-    validateProjectId: (projectId: string) => void;
-    validateBranchName: (branchName: string) => void;
-};
-/**
- * The additional targets a message declares, checked and deduplicated: only
- * project branches, each structurally valid, none equal to the primary
- * target. A malformed entry is a protocol violation and fails the command
- * before admission rather than silently narrowing its fence.
- */
-export declare function normalizeCommandAdditionalTargets(primary: WorkspaceCommandAnyTarget, additional: unknown, validators: WorkspaceCommandTargetValidators): WorkspaceCommandProjectTarget[];
-/** Every target a command fences, primary first. */
-export declare function commandTargets<T extends WorkspaceCommandAnyTarget>(primary: T, additional: readonly WorkspaceCommandProjectTarget[]): Array<T | WorkspaceCommandProjectTarget>;
-/** Log suffix naming the additional checkouts a command fences; empty when there are none. */
-export declare function describeCommandAdditionalTargets(additional: readonly WorkspaceCommandProjectTarget[]): string;

package/dist/types/workspace-filesystem-executor-thread.d.ts

@@ -1 +0,0 @@
-export {};