@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/types/plan-parser.d.ts

@@ -1,38 +0,0 @@
-/**
- * Markdown plan parser.
- *
- * Plans are plain Markdown files. The only structured region is the first
- * "## Tasks" section, which contains checkbox task lines.
- */
-export declare const PLAN_TASK_ID_REGEX: RegExp;
-export declare const PLAN_TASK_LINE_REGEX: RegExp;
-export declare const PLAN_TASKS_HEADING_REGEX: RegExp;
-export interface PlanTask {
-    id: string;
-    description: string;
-    checked: boolean;
-    lineNumber: number;
-}
-export interface ParsedPlan {
-    id: string;
-    title: string;
-    content: string;
-    tasks: PlanTask[];
-    currentTask: PlanTask | null;
-    complete: boolean;
-    tasksStartLine: number | null;
-    tasksEndLine: number | null;
-}
-export type ParsedMarkdownPlan = ParsedPlan;
-export declare function getPlanMetadata(content: string): {
-    title: string;
-};
-export declare function getTasksSectionRange(content: string): {
-    startIndex: number;
-    endIndex: number;
-} | null;
-export declare function parseMarkdownPlan(content: string, planId: string): ParsedPlan;
-export declare const parsePlan: typeof parseMarkdownPlan;
-export declare function createPlanMarkdown(planId: string, title?: string): string;
-export declare function updateTaskCheckbox(content: string, taskId: string, checked: boolean): string;
-export declare function formatPlanTitle(planId: string): string;

package/dist/types/plan-paths.d.ts

@@ -1,36 +0,0 @@
-type PlanTarget = {
-    type: "project";
-} | {
-    type: "workspace";
-    rootProfile: "visible_projects" | "canonical_sync";
-};
-export declare const PLAN_EXTENSION = ".plan.md";
-export declare function validatePlanId(planId: string): void;
-export declare function assertPlanTarget(target: PlanTarget): void;
-export declare function getWorkerPlansPath(target: PlanTarget): string;
-/** The same worker path is used in prompts, injected reads, and file tools. */
-export declare function getWorkerPlanPath(target: PlanTarget, planId: string): string;
-export type WorkerReadPlanInput = {
-    planId: string;
-    createIfMissing: boolean;
-};
-export type WorkerLintPlansInput = {
-    glob?: string;
-};
-export type WorkerUpdatePlanTaskInput = {
-    planId: string;
-    taskId: string;
-    checked: boolean;
-};
-export type WorkerLintPlansResult = {
-    type: "lint_plans";
-    content: string;
-};
-export type WorkerUpdatePlanTaskResult = {
-    type: "update_task_status";
-    planId: string;
-    taskId: string;
-    checked: boolean;
-    message: string;
-};
-export {};

package/dist/types/port-forward-client.d.ts

@@ -1,8 +0,0 @@
-export declare function openWorkerPortForwardRelay(options: {
-    baseUrl: string;
-    token: string;
-    label: string;
-    forwardId: string;
-    relayConnectionId: string;
-    workerPort: number;
-}): void;

package/dist/types/project-checkout-garbage.d.ts

@@ -1,86 +0,0 @@
-/**
- * Where a deleted branch checkout waits for collection. Staging is the only
- * platform write into this directory and a live checkout always lives at
- * `<projectRoot>/<branch>`, so a crash between staging and collection leaves
- * nothing that a later sweep could confuse with a replacement branch. The
- * filesystem is user-managed, though, so the collector never trusts the name
- * alone: it removes only real directories or leaf links that sit under a real
- * garbage directory of a real project directory (see `ownedStagedPath`).
- * Distinct from `.r5d-removed`, which preserves paths that were not this
- * project's worktree.
- */
-export declare const PROJECT_DELETED_CHECKOUTS_DIRECTORY = ".r5d-deleted";
-/**
- * Rename a checkout this project owns out of the active namespace. One
- * same-filesystem rename takes milliseconds whatever the tree holds, so the
- * branch mutation lease is released long before the bytes are gone. The
- * garbage directory must be a real directory: a planted link would make the
- * later collection walk through it, so staging refuses rather than continue.
- */
-export declare function stageProjectCheckoutForDeletion(projectRoot: string, branchName: string, checkoutPath: string): string;
-/**
- * Rename a whole project root out of the active namespace, into the
- * namespace's garbage directory, so removing a deleted project never walks
- * its checkouts on the worker event loop. Same guarantees as
- * stageProjectCheckoutForDeletion: one same-filesystem rename, a real garbage
- * directory, collection by the garbage collector later.
- */
-export declare function stageProjectForDeletion(projectsRoot: string, projectRoot: string): string;
-/**
- * True when `candidate` is lexically a direct entry of a project's garbage
- * directory (`<namespace>/<project>/.r5d-deleted/<entry>`, a staged checkout)
- * or of a namespace's garbage directory (`<namespace>/.r5d-deleted/<entry>`,
- * a staged whole project) under `projectsRoot`.
- */
-export declare function isStagedProjectCheckoutPath(projectsRoot: string, candidate: string): boolean;
-/**
- * Whether a lexically staged path is safe to remove right now: every ancestor
- * below the projects root is a real directory (a linked namespace, project,
- * or garbage directory would let a removal reach an unrelated tree through
- * the link), and the entry itself is a real directory or a leaf link. Checked
- * again immediately before the removal starts, never only at enqueue time.
- */
-export declare function ownedStagedPath(projectsRoot: string, candidate: string): {
-    kind: "directory" | "link";
-} | null;
-/**
- * Every owned staged checkout under `<projectsRoot>/<namespace>/<project>/.r5d-deleted/`
- * and every owned staged project under `<projectsRoot>/<namespace>/.r5d-deleted/`;
- * linked ancestors are not followed.
- */
-export declare function discoverStagedProjectCheckouts(projectsRoot: string): string[];
-/**
- * Delete a staged tree in a child process so a large recursive removal never
- * runs on the worker event loop, at the lowest CPU and (where supported) I/O
- * priority so live agents on the same volume keep their share. A leaf link is
- * unlinked in place; its target is never followed.
- */
-export declare function removeStagedProjectCheckout(stagedPath: string): Promise<void>;
-type Logger = (message: string) => void;
-/**
- * Collects staged checkouts one at a time, outside every workspace lease.
- * Entries are enqueued right after staging and by `sweep()` at worker start,
- * so a crash at any point converges on the next start. A failed removal is
- * logged and left for the next sweep.
- */
-export declare class ProjectCheckoutGarbageCollector {
-    private readonly projectsRoot;
-    private readonly remove;
-    private readonly log;
-    private readonly queued;
-    private tail;
-    private collectedCount;
-    constructor(options: {
-        projectsRoot: string;
-        remove?: (stagedPath: string) => Promise<void>;
-        log?: Logger;
-    });
-    /** Number of removals that have completed successfully. */
-    get collected(): number;
-    /** Resolves once everything queued so far has been attempted. */
-    get idle(): Promise<void>;
-    enqueue(stagedPath: string): void;
-    /** Enqueue every staged checkout left behind by an earlier process. */
-    sweep(): number;
-}
-export {};

package/dist/types/project-mirror-fetch-policy.d.ts

@@ -1,84 +0,0 @@
-/**
- * Decides which part of a project's hidden mirror a periodic observation must
- * fetch, from the tokens the server advertises and the tokens the worker's
- * own mirror refs cover (both computed with `project-mirror-refs-token.ts`).
- *
- * Skipping is fail-open: any missing or mismatched information fetches.
- *
- * There is deliberately no timed backstop refetch for matching tokens. The
- * server recomputes every advertised token from the canonical repository on
- * disk on each heartbeat sweep, so a matching token is a fresh statement that
- * the fetch would transfer nothing, whoever moved the refs. The worker
- * records the tokens it covers from its own refs after every fetch and lease
- * push, with the same shared formula, so a skip can only be stale if the
- * canonical repository moved after the sweep that produced the advertisement
- * — which the next sweep corrects, exactly like a tip that lands mid-cycle —
- * or if the formula itself were wrong, which the shared module and its locked
- * vectors guard and a periodic blind fetch would only hide. A project or
- * mount the server advertises no token for fetches every cycle, as before
- * tokens existed.
- */
-/** Why a fetch runs. `fail_closed` is never decided here: reset and remediation observation bypasses the gate. */
-export type ProjectMirrorFetchReason = "skipping_disabled" | "no_advertised_token" | "never_fetched" | "token_changed" | "fail_closed";
-export type ProjectMirrorFetchDecision = {
-    fetch: true;
-    reason: ProjectMirrorFetchReason;
-} | {
-    fetch: false;
-    reason: "token_match";
-};
-export declare function projectMirrorFetchDecision(input: {
-    advertisedToken: string | undefined;
-    fetchedToken: string | undefined;
-    skippingEnabled: boolean;
-}): ProjectMirrorFetchDecision;
-export type ProjectMirrorObservationFetchPlan = 
-/** Fetch every canonical ref of the project, as observation always did before per-mount tokens. */
-{
-    scope: "project";
-    reason: ProjectMirrorFetchReason;
-}
-/** Fetch only the named mounts' branch heads and handoff refs. */
- | {
-    scope: "mounts";
-    mounts: Array<{
-        branchName: string;
-        reason: ProjectMirrorFetchReason;
-    }>;
-}
-/** Every token the observation depends on matches; reuse the local refs. */
- | {
-    scope: "none";
-};
-/**
- * Plan one project's observation fetch. With per-mount tokens advertised for
- * the project, each mount decides for itself and only changed mounts fetch;
- * without them (an older server) the project token decides for the whole
- * mirror.
- */
-export declare function planProjectMirrorObservationFetch(input: {
-    branchNames: readonly string[];
-    advertisedProjectToken: string | undefined;
-    /** Per-mount tokens for this project, keyed by branch name; undefined when the server advertised none. */
-    advertisedMountTokens: ReadonlyMap<string, string> | undefined;
-    fetchedProjectToken: string | undefined;
-    fetchedMountTokens: ReadonlyMap<string, string>;
-    skippingEnabled: boolean;
-}): ProjectMirrorObservationFetchPlan;
-export type ProjectMirrorRefsTokensAdvertisement = {
-    /** One token per project id. */
-    projectTokens: Map<string, string>;
-    /** Per-mount tokens keyed by project id then branch name; a project is present only when the server advertised mount tokens for it. */
-    mountTokens: Map<string, Map<string, string>>;
-    /** Current head of the user's hidden workspace repository, when advertised. */
-    workspaceHead: string | undefined;
-};
-/**
- * Read a `project_mirror_refs_tokens` message. Older servers send only
- * `tokens`; malformed entries are dropped, which fails open into fetching.
- */
-export declare function parseProjectMirrorRefsTokensMessage(message: {
-    tokens?: unknown;
-    mountTokens?: unknown;
-    workspaceHead?: unknown;
-}): ProjectMirrorRefsTokensAdvertisement;

package/dist/types/project-mirror-refs-token.d.ts

@@ -1,53 +0,0 @@
-/** Canonical namespaces the token hashes; also the observation fetch's sources. */
-export declare const PROJECT_MIRROR_REFS_TOKEN_NAMESPACES: readonly ["refs/heads/", "refs/r5d/server-synced/"];
-/** Worker-local copy of a canonical `refs/heads/*` ref. */
-export declare const PROJECT_MIRROR_REF_PREFIX = "refs/r5d/mirror/";
-export declare const PROJECT_SERVER_SYNCED_REF_PREFIX = "refs/r5d/server-synced/";
-/** `git for-each-ref` format both sides list refs with; see parseProjectMirrorRefListing. */
-export declare const PROJECT_MIRROR_REF_LISTING_FORMAT = "--format=%(objectname) %(refname)";
-export type ProjectMirrorRef = {
-    refname: string;
-    objectName: string;
-};
-/** One checked-out project branch, identified by its durable incarnation id. */
-export type ProjectMirrorMount = {
-    branchName: string;
-    branchId: string;
-};
-export type ProjectMirrorRefsTokens = {
-    /** Hash over every ref in the observed namespaces. */
-    project: string;
-    /** Hash over one mount's branch head plus its handoff refs, keyed by branch name. */
-    mounts: Map<string, string>;
-};
-/**
- * Hash a ref listing into a mirror-refs token. Both sides sort here rather
- * than trusting git's listing order: renaming `refs/r5d/mirror/*` back to
- * `refs/heads/*` changes sort neighborhoods.
- */
-export declare function hashProjectMirrorRefs(refs: readonly ProjectMirrorRef[]): string;
-/**
- * Parse `git for-each-ref` output produced with
- * PROJECT_MIRROR_REF_LISTING_FORMAT. Malformed rows throw rather than being
- * dropped: a caller that cannot trust its listing must not produce a token.
- * With `namespaces`, rows outside them throw too.
- */
-export declare function parseProjectMirrorRefListing(output: string, options?: {
-    namespaces?: readonly string[];
-}): ProjectMirrorRef[];
-/**
- * Rename locally fetched mirror refs into the namespaces the server hashes.
- * Rows outside the two observed namespaces are dropped; the caller lists only
- * those namespaces, so a dropped row means an unexpected listing, and dropping
- * it can only make tokens differ — which fails open into a fetch.
- */
-export declare function canonicalizeLocalProjectMirrorRefs(refs: readonly ProjectMirrorRef[]): ProjectMirrorRef[];
-/** The canonical refs one mount's token covers: its branch head and its server-synced handoff refs. */
-export declare function projectMirrorMountRefs(refs: readonly ProjectMirrorRef[], mount: ProjectMirrorMount): ProjectMirrorRef[];
-/**
- * Compute the project token and one token per mount from one canonical ref
- * listing. A mount's token is the project formula applied to the mount's own
- * refs, so a mount whose branch is the only ref of its project has the same
- * token as the project.
- */
-export declare function projectMirrorRefsTokens(refs: readonly ProjectMirrorRef[], mounts: readonly ProjectMirrorMount[]): ProjectMirrorRefsTokens;

package/dist/types/project-workspace-state.d.ts

@@ -1,188 +0,0 @@
-import { type CheckoutPathSegments } from "./managed-paths";
-export declare const PROJECT_WORKSPACE_STATE_FILE = "project-workspace-state.json";
-export type ProjectWorkspaceDesiredProjectInput = {
-    projectId: string;
-    checkoutPathSegments: CheckoutPathSegments;
-    defaultBranch: string;
-    branches: readonly {
-        branchName: string;
-    }[];
-};
-export type ProjectWorkspaceDesiredProject = {
-    projectId: string;
-    checkoutPathSegments: CheckoutPathSegments;
-    defaultBranch: string;
-    branches: Array<{
-        branchName: string;
-    }>;
-};
-export type LocallyPendingCreatedProjectBranch = {
-    /** Durable project_branches row incarnation; absent only in legacy state. */
-    branchId?: string;
-    projectId: string;
-    branchName: string;
-};
-export type PreserveOnlyProjectBranch = {
-    branchId: string;
-    projectId: string;
-    branchName: string;
-};
-export type EnabledRepositoryTransition = {
-    projectId: string;
-    transitionId: string | null;
-};
-type ProjectWorkspaceDeletionBase = {
-    id: string;
-    projectId: string;
-    checkoutPathSegments: CheckoutPathSegments;
-    treePublishedHead: string | null;
-    mirrorRefsDeleted: string[];
-};
-export type ProjectWorkspaceBranchDeletionTombstone = ProjectWorkspaceDeletionBase & {
-    kind: "branch";
-    branchName: string;
-};
-export type ProjectWorkspaceProjectDeletionTombstone = ProjectWorkspaceDeletionBase & {
-    kind: "project";
-    branchNames: string[];
-};
-export type ProjectWorkspaceDeletionTombstone = ProjectWorkspaceBranchDeletionTombstone | ProjectWorkspaceProjectDeletionTombstone;
-export type PendingProjectWorkspaceTreeDeletion = {
-    tombstoneId: string;
-    kind: "branch";
-    projectId: string;
-    checkoutPathSegments: CheckoutPathSegments;
-    branchName: string;
-    managedPath: string;
-    primaryBranchName: string | null;
-} | {
-    tombstoneId: string;
-    kind: "project";
-    projectId: string;
-    checkoutPathSegments: CheckoutPathSegments;
-    branchNames: string[];
-    managedPath: string;
-    projectDeleted: boolean;
-};
-export type PendingProjectMirrorRefDeletion = {
-    tombstoneId: string;
-    projectId: string;
-    branchName: string;
-    checkoutPathSegments: CheckoutPathSegments;
-    managedPath: string;
-    primaryBranchName: string | null;
-    treePublishedHead: string;
-};
-export type ProjectWorkspaceStateView = {
-    desiredProjects: ProjectWorkspaceDesiredProject[];
-    effectiveDesiredProjects: ProjectWorkspaceDesiredProject[];
-    locallyPendingCreatedBranches: LocallyPendingCreatedProjectBranch[];
-    enabledRepositoryTransitions: EnabledRepositoryTransition[];
-    tombstones: ProjectWorkspaceDeletionTombstone[];
-    pendingTreeDeletions: PendingProjectWorkspaceTreeDeletion[];
-    pendingMirrorRefDeletions: PendingProjectMirrorRefDeletion[];
-};
-export declare class ProjectWorkspacePendingBranchPathChangeError extends Error {
-    readonly projectId: string;
-    readonly branchName: string;
-    readonly currentCheckoutPathSegments: CheckoutPathSegments;
-    readonly incomingCheckoutPathSegments: CheckoutPathSegments;
-    constructor(input: {
-        projectId: string;
-        branchName: string;
-        currentCheckoutPathSegments: CheckoutPathSegments;
-        incomingCheckoutPathSegments: CheckoutPathSegments;
-    });
-}
-export declare class ProjectWorkspaceCheckoutPathCollisionError extends Error {
-    readonly projectId: string;
-    readonly occupyingProjectId: string;
-    readonly checkoutPathSegments: CheckoutPathSegments;
-    constructor(input: {
-        projectId: string;
-        occupyingProjectId: string;
-        checkoutPathSegments: CheckoutPathSegments;
-    });
-}
-export type StaleOuterProjectWorkspaceBranch = {
-    kind: "branch";
-    projectId: string;
-    branchName: string;
-    projectTreePath: string | null;
-    planTreePath: string | null;
-};
-export type StaleOuterProjectWorkspaceProject = {
-    kind: "project";
-    projectId: string;
-    projectTreePath: string | null;
-    planTreePath: string | null;
-    branches: Array<{
-        branchName: string;
-        projectTreePath: string | null;
-        planTreePath: string | null;
-    }>;
-};
-export type StaleOuterProjectWorkspaceEntry = StaleOuterProjectWorkspaceBranch | StaleOuterProjectWorkspaceProject;
-/**
- * A fresh authoritative configuration wins over any deletion staged by an
- * older configuration. Remove only exact project/branch targets so unrelated
- * cleanup (including an old checkout-path tombstone) remains durable.
- */
-export declare function pruneAuthoritativelyDesiredBranchDeletions<T extends LocallyPendingCreatedProjectBranch>(pendingDeletions: Map<string, T>, desiredProjects: readonly ProjectWorkspaceDesiredProjectInput[]): void;
-/**
- * Discover legacy outer-tree entries without trusting or walking arbitrary
- * filesystem names. Only canonical managed project ids and encoded branch
- * directory names are returned; symlinks, files, and non-layout entries are
- * deliberately left for an operator.
- */
-export declare function discoverStaleOuterProjectWorkspaceEntries(input: {
-    workspaceShadowRoot: string;
-    desiredProjects: readonly ProjectWorkspaceDesiredProjectInput[];
-    locallyPendingCreatedBranches?: readonly LocallyPendingCreatedProjectBranch[];
-}): StaleOuterProjectWorkspaceEntry[];
-/**
- * Durable worker-local ledger for desired project mounts and ordered deletion
- * side effects. The caller must remove each managed path before including its
- * tombstone in an outer-tree publication. Mirror refs may be acknowledged only
- * after that publication is durably recorded.
- */
-export declare class ProjectWorkspaceStateStore {
-    readonly stateRoot: string;
-    readonly projectsRoot: string;
-    readonly statePath: string;
-    constructor(input: {
-        stateRoot: string;
-        projectsRoot: string;
-    });
-    read(): ProjectWorkspaceStateView;
-    discoverStaleOuterEntries(workspaceShadowRoot: string): StaleOuterProjectWorkspaceEntry[];
-    reconcile(input: {
-        desiredProjects: readonly ProjectWorkspaceDesiredProjectInput[];
-        locallyPendingCreatedBranches?: readonly LocallyPendingCreatedProjectBranch[];
-        preserveOnlyBranches?: readonly PreserveOnlyProjectBranch[];
-    }): Promise<ProjectWorkspaceStateView>;
-    /** Record a successful enabled reseed without letting disabled config consume it. */
-    recordEnabledRepositoryTransition(input: EnabledRepositoryTransition): Promise<ProjectWorkspaceStateView>;
-    /** Persist the create intent before invoking Git so a crash cannot orphan an untracked worktree. */
-    recordPendingCreatedBranch(input: LocallyPendingCreatedProjectBranch & {
-        branchId: string;
-    }): Promise<ProjectWorkspaceStateView>;
-    /** Roll back an intent only when Git failed before creating its branch. */
-    rollbackPendingCreatedBranch(input: LocallyPendingCreatedProjectBranch): Promise<ProjectWorkspaceStateView>;
-    /** Clear a create intent after an authoritative desired config contains it. */
-    clearPendingCreatedBranch(input: LocallyPendingCreatedProjectBranch): Promise<ProjectWorkspaceStateView>;
-    /** Persist a branch tombstone before mutating its linked worktree or local ref. */
-    beginBranchDeletion(input: LocallyPendingCreatedProjectBranch): Promise<ProjectWorkspaceStateView>;
-    recordTreePublication(input: {
-        tombstoneIds: readonly string[];
-        publishedHead: string;
-    }): Promise<ProjectWorkspaceStateView>;
-    recordMirrorRefDeletion(input: {
-        tombstoneId: string;
-        branchName: string;
-    }): Promise<ProjectWorkspaceStateView>;
-}
-export declare const projectWorkspaceStateTestHarness: {
-    writeEmptyStateAtDurableRootBoundary(stateRoot: string, afterStateRootFsync: () => void): Promise<void>;
-};
-export {};