@vimhead.dev/norn 0.1.0-tip.35390859630.1 → 0.1.0-tip.35568631545.1

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { CreateAgentSessionOptions, EventBus, PromptOptions } from "@earendil-works/pi-coding-agent";
+import type { CreateAgentSessionOptions, EventBus, PromptOptions, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type, type StaticDecode, type StaticEncode, type TCodec, type TSchema } from "typebox";
 import type { TLocalizedValidationError } from "typebox/error";
 declare const WORKFLOW_DECLARATION_KIND = "norn.workflow";
@@ -8,11 +8,13 @@ export type NornWorkflowAnyGate = {
     readonly enabled: true;
     readonly fields?: readonly string[];
 };
-export type NornWorkflowIsolationMode = "runWorkspace" | "project";
-export type NornWorkflowIsolation<Mode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
-    readonly mode: Mode;
+export type NornWorkflowPaths = {
+    /** Absolute project root. Excluded from run checkpoints and rollback. */
+    readonly project: string;
+    /** Absolute, initially empty workspace. Saved in run checkpoints and restored on rollback. */
+    readonly workspace: string;
 };
-export type NornWorkflowDeclaration<Id extends string = string, ArgsSchema extends TSchema = TSchema, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode, ConfigSchema extends TSchema | undefined = TSchema | undefined, Scope extends NornWorkflowScopeInfo | undefined = NornWorkflowScopeInfo | undefined> = {
+export type NornWorkflowDeclaration<Id extends string = string, ArgsSchema extends TSchema = TSchema, ConfigSchema extends TSchema | undefined = TSchema | undefined, Scope extends NornWorkflowScopeInfo | undefined = NornWorkflowScopeInfo | undefined> = {
     (args: StaticEncode<ArgsSchema>): NornRunNext;
     readonly kind: typeof WORKFLOW_DECLARATION_KIND;
     readonly id: Id;
@@ -20,12 +22,11 @@ export type NornWorkflowDeclaration<Id extends string = string, ArgsSchema exten
     readonly instructions?: string;
     readonly args: ArgsSchema;
     readonly gate?: NornWorkflowGate<ArgsSchema> & {
-        describe?(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<string>;
+        describe?(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<string>;
     };
-    readonly isolation: NornWorkflowIsolation<IsolationMode>;
     readonly config?: ConfigSchema;
     readonly scope: Scope;
-    execute(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
+    execute(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
 };
 export type NornAnyWorkflowDeclaration = Pick<NornWorkflowDeclaration, keyof NornWorkflowDeclaration> & ((args: never) => NornRunNext);
 export type NornWorkflowRefSchemaOptions<ArgsSchema extends TSchema = TSchema> = {
@@ -49,48 +50,50 @@ type NornWorkflowInstructions = {
     readonly isEntrypoint: false;
     readonly instructions?: string;
 };
-type RunForIsolation<Mode extends NornWorkflowIsolationMode> = Mode extends "project" ? NornProjectRun : NornRun;
 type WorkflowConfig<Schema extends TSchema | undefined> = Schema extends TSchema ? StaticDecode<Schema> : undefined;
-export type NornWorkflowContext<ArgsSchema extends TSchema = TSchema, Mode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode, ConfigSchema extends TSchema | undefined = TSchema | undefined, Scope extends NornWorkflowScopeInfo | undefined = NornWorkflowScopeInfo | undefined> = {
+export type NornWorkflowContext<ArgsSchema extends TSchema = TSchema, ConfigSchema extends TSchema | undefined = TSchema | undefined, Scope extends NornWorkflowScopeInfo | undefined = NornWorkflowScopeInfo | undefined> = {
     readonly args: StaticDecode<ArgsSchema>;
     readonly config: WorkflowConfig<ConfigSchema>;
-    readonly run: RunForIsolation<Mode>;
+    readonly paths: NornWorkflowPaths;
+    readonly agents: NornAgents;
+    readonly commands: NornCommands;
+    readonly logs: NornLogs;
+    readonly run: NornRun;
 } & (Scope extends NornWorkflowScopeInfo ? {
     readonly scope: {
         readonly id: Scope["id"];
         readonly config: WorkflowConfig<Scope["config"]>;
     };
 } : {});
-export type NornWorkflowDefinition<Id extends string = string, ArgsSchema extends TSchema = TSchema, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode, ConfigSchema extends TSchema | undefined = undefined, Scope extends NornWorkflowScopeInfo | undefined = undefined> = {
-    readonly id: Id;
+export type NornWorkflowDefinition<Name extends string = string, ArgsSchema extends TSchema = TSchema, ConfigSchema extends TSchema | undefined = undefined, Scope extends NornWorkflowScopeInfo | undefined = undefined> = {
+    readonly name: Name;
     readonly args: ArgsSchema;
     readonly config?: ConfigSchema;
-    readonly isolation?: NornWorkflowIsolation<IsolationMode>;
     readonly gate?: NornWorkflowGate<ArgsSchema> & {
-        describe?(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<string>;
+        describe?(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<string>;
     };
-    execute(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
+    execute(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
 } & NornWorkflowInstructions;
 export type NornWorkflowScopeInfo = {
     readonly id: string;
     readonly config?: TSchema;
 };
-export type NornWorkflowScope<Id extends string, ConfigSchema extends TSchema | undefined> = {
-    readonly id: Id;
+export type NornWorkflowScope<Name extends string, ConfigSchema extends TSchema | undefined> = {
+    readonly id: Name;
     readonly config: ConfigSchema;
-    workflow<const LocalId extends string, ArgsSchema extends TSchema, const Mode extends NornWorkflowIsolationMode = "runWorkspace", LocalConfig extends TSchema | undefined = undefined>(definition: NornWorkflowDefinition<LocalId, ArgsSchema, Mode, LocalConfig, {
-        readonly id: Id;
+    workflow<const LocalName extends string, ArgsSchema extends TSchema, LocalConfig extends TSchema | undefined = undefined>(definition: NornWorkflowDefinition<LocalName, ArgsSchema, LocalConfig, {
+        readonly id: Name;
         readonly config: ConfigSchema;
-    }>): NornWorkflowDeclaration<`${Id}.${LocalId}`, ArgsSchema, Mode, LocalConfig, {
-        readonly id: Id;
+    }>): NornWorkflowDeclaration<`${Name}.${LocalName}`, ArgsSchema, LocalConfig, {
+        readonly id: Name;
         readonly config: ConfigSchema;
     }>;
 };
-export declare function workflow<const Id extends string, ArgsSchema extends TSchema, const Mode extends NornWorkflowIsolationMode = "runWorkspace", ConfigSchema extends TSchema | undefined = undefined>(definition: NornWorkflowDefinition<Id, ArgsSchema, Mode, ConfigSchema>): NornWorkflowDeclaration<Id, ArgsSchema, Mode, ConfigSchema, undefined>;
-export declare function workflowScope<const Id extends string, ConfigSchema extends TSchema | undefined = undefined>(input: {
-    readonly id: Id;
+export declare function workflow<const Name extends string, ArgsSchema extends TSchema, ConfigSchema extends TSchema | undefined = undefined>(definition: NornWorkflowDefinition<Name, ArgsSchema, ConfigSchema>): NornWorkflowDeclaration<Name, ArgsSchema, ConfigSchema, undefined>;
+export declare function workflowScope<const Name extends string, ConfigSchema extends TSchema | undefined = undefined>(input: {
+    readonly name: Name;
     readonly config?: ConfigSchema;
-}): NornWorkflowScope<Id, ConfigSchema>;
+}): NornWorkflowScope<Name, ConfigSchema>;
 export type NornRunNext = {
     readonly type: "next";
     readonly workflowId: string;
@@ -98,7 +101,6 @@ export type NornRunNext = {
 };
 export type NornRunOutcomeMetadata = {
     readonly summary?: string;
-    readonly artifacts?: Record<string, NornArtifactRef>;
     readonly logs?: Record<string, NornLogRef>;
     readonly data?: Record<string, unknown>;
 };
@@ -113,11 +115,6 @@ export type NornRunFail = {
     };
 };
 export type WorkflowResult = NornRunNext | NornRunComplete | NornRunFail;
-export type NornRunFor<TWorkflow extends NornAnyWorkflowDeclaration> = TWorkflow extends {
-    readonly isolation: {
-        readonly mode: "project";
-    };
-} ? NornProjectRun : NornRun;
 export type NornRunStartOptions = {
     readonly id?: string;
     readonly name?: string;
@@ -195,6 +192,7 @@ export type NornRunInfo = {
     readonly id: string;
     readonly name: string;
     readonly path: string;
+    readonly paths: NornWorkflowPaths;
     readonly entrypointWorkflowId: string;
     readonly currentWorkflowId?: string;
     readonly status: NornRunStatus;
@@ -220,14 +218,10 @@ export type NornRunCheckpoint = {
 export type NornCommandRunInput = {
     readonly label: string;
     readonly command: string | readonly [string, ...string[]];
-    readonly cwd?: string;
+    readonly cwd: string;
     readonly env?: Record<string, string>;
     readonly timeoutMs?: number;
 };
-export declare const artifactRefSchema: Type.TObject<{
-    path: Type.TString;
-}>;
-export type NornArtifactRef = StaticDecode<typeof artifactRefSchema>;
 declare const emptyWorkflowRefArgsSchema: Type.TObject<{}>;
 declare const workflowReferenceInputSchema: Type.TUnion<[Type.TString, Type.TObject<{
     workflow: Type.TString;
@@ -252,9 +246,9 @@ export type NornAgentBeforeSessionStartContext = {
     readonly events: EventBus;
 };
 export type NornAgentCreateSessionInput = {
-    readonly resourceAdapters?: readonly import("./agent-resource-adapter.ts").NornAgentResourceAdapter[];
+    readonly customTools?: readonly ToolDefinition[];
     readonly label: string;
-    readonly cwd?: string;
+    readonly cwd: string;
     readonly tools?: string[];
     readonly beforeSessionStart?: (context: NornAgentBeforeSessionStartContext) => MaybePromise<void>;
     readonly model?: CreateAgentSessionOptions["model"];
@@ -366,36 +360,23 @@ export type NornAgentSession = {
     prompt<ResponseSchema extends TSchema>(input: NornAgentPromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
     dispose(): Promise<void>;
 };
-export type NornRun = NornRunBase;
-export type NornProjectRun = NornRunBase & {
-    projectRoot: string;
-    projectPath(relativePath: string): string;
-};
-type NornRunBase = {
+export type NornRun = {
     id: string;
-    workspace: string;
-    cwd: string;
-    path(relativePath: string): string;
     next(workflowId: string, args: unknown): NornRunNext;
     complete(metadata?: NornRunOutcomeMetadata): NornRunComplete;
     fail(metadata: NornRunOutcomeMetadata & {
         readonly summary: string;
     }): NornRunFail;
-    resources: import("./resources.ts").NornResources;
-    artifacts: {
-        write(path: string, content: string): Promise<NornArtifactRef>;
-        read(ref: NornArtifactRef): Promise<string>;
-    };
-    logs: {
-        read(log: NornLogRef): Promise<string>;
-    };
-    commands: {
-        run(input: NornCommandRunInput): Promise<NornCommandRunResult>;
-    };
-    agents: {
-        createSession(input: NornAgentCreateSessionInput): Promise<NornAgentSession>;
-        prompt<ResponseSchema extends TSchema>(input: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
-    };
+};
+export type NornLogs = {
+    read(log: NornLogRef): Promise<string>;
+};
+export type NornCommands = {
+    run(input: NornCommandRunInput): Promise<NornCommandRunResult>;
+};
+export type NornAgents = {
+    createSession(input: NornAgentCreateSessionInput): Promise<NornAgentSession>;
+    prompt<ResponseSchema extends TSchema>(input: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
 };
 export type NornWorkflowSource = {
     readonly path: string;
@@ -410,7 +391,6 @@ export type NornRegisteredWorkflowInfo = {
     readonly id: string;
     readonly instructions?: string;
     readonly isEntrypoint: boolean;
-    readonly isolation: NornWorkflowIsolation;
     readonly scope?: {
         readonly id: string;
     };

package/dist/api.js

@@ -12,36 +12,32 @@ import { Value } from "typebox/value";
 import { assertWorkflowMetadata, isPlainObject, jsonValueSchema } from "./schema.js";
 var WORKFLOW_DECLARATION_KIND = "norn.workflow";
 function workflow(definition) {
-  return createWorkflow({ definition, scope: void 0 });
+  return createWorkflow({ definition, id: definition.name, scope: void 0 });
 }
 function createWorkflow(input) {
-  const { definition, scope } = input;
-  assertDeclarationId(definition.id);
-  const callable = (args) => createWorkflowTransition({ workflowId: definition.id, args });
-  const result = Object.assign(callable, definition, {
+  const { definition: { name, ...properties }, id, scope } = input;
+  assertDeclarationName(name);
+  const callable = (args) => createWorkflowTransition({ workflowId: id, args });
+  const result = Object.assign(callable, properties, {
     kind: WORKFLOW_DECLARATION_KIND,
-    scope,
-    isolation: definition.isolation ?? { mode: "runWorkspace" }
+    id,
+    scope
   });
-  if (!isWorkflowDeclaration(result)) throw new Error(`Invalid workflow definition: ${definition.id}`);
+  if (!isWorkflowDeclaration(result)) throw new Error(`Invalid workflow definition: ${id}`);
   assertWorkflowMetadata(result);
   return result;
 }
 function workflowScope(input) {
-  assertDeclarationId(input.id);
-  const scope = { id: input.id, config: input.config };
+  assertDeclarationName(input.name);
+  const scope = { id: input.name, config: input.config };
   return {
-    id: input.id,
-    config: input.config,
+    id: scope.id,
+    config: scope.config,
     workflow(definition) {
-      assertDeclarationId(definition.id);
-      return createWorkflow({ definition: { ...definition, id: `${input.id}.${definition.id}` }, scope });
+      return createWorkflow({ definition, id: `${scope.id}.${definition.name}`, scope });
     }
   };
 }
-var artifactRefSchema = Type.Object({
-  path: Type.String()
-});
 var emptyWorkflowRefArgsSchema = Type.Object({});
 var workflowReferenceInputSchema = Type.Union([
   Type.String({ minLength: 1 }),
@@ -60,13 +56,13 @@ function workflowRefSchema(options) {
     };
   }), { "x-norn-workflow-ref": { contributedArgsSchema: contributionSchema } });
 }
-function assertDeclarationId(id) {
-  if (typeof id !== "string" || id.trim().length === 0 || id.split(".").some((segment) => segment.length === 0)) throw new Error(`Invalid workflow or scope id: ${id}`);
+function assertDeclarationName(name) {
+  if (typeof name !== "string" || name.trim().length === 0 || name.includes(".")) throw new Error(`Invalid workflow or scope name: ${name}; expected a nonempty name without dots`);
 }
 function isWorkflowDeclaration(value) {
   if (typeof value !== "function") return false;
   const candidate = value;
-  return candidate.kind === WORKFLOW_DECLARATION_KIND && typeof candidate.id === "string" && candidate.id.length > 0 && (candidate.instructions === void 0 || typeof candidate.instructions === "string") && typeof candidate.isEntrypoint === "boolean" && Boolean(candidate.args) && typeof candidate.execute === "function" && (candidate.isolation?.mode === "runWorkspace" || candidate.isolation?.mode === "project");
+  return candidate.kind === WORKFLOW_DECLARATION_KIND && typeof candidate.id === "string" && candidate.id.length > 0 && (candidate.instructions === void 0 || typeof candidate.instructions === "string") && typeof candidate.isEntrypoint === "boolean" && Boolean(candidate.args) && typeof candidate.execute === "function";
 }
 function isWorkflowNext(value) {
   if (!value || typeof value !== "object") return false;
@@ -84,7 +80,6 @@ function isWorkflowFail(value) {
   return candidate.type === "fail" && typeof candidate.metadata?.summary === "string" && candidate.metadata.summary.length > 0;
 }
 export {
-  artifactRefSchema,
   isWorkflowComplete,
   isWorkflowDeclaration,
   isWorkflowFail,

package/dist/index.d.ts

@@ -1,5 +1,2 @@
 export type { CreateAgentSessionOptions, EventBus, PromptOptions, ToolDefinition } from "@earendil-works/pi-coding-agent";
 export * from "./api.ts";
-export { NornFileCoordinator } from "./files.ts";
-export * from "./resources.ts";
-export * from "./agent-resource-adapter.ts";

package/dist/index.js

@@ -1,8 +1,2 @@
 // src/index.ts
 export * from "./api.js";
-import { NornFileCoordinator } from "./files.js";
-export * from "./resources.js";
-export * from "./agent-resource-adapter.js";
-export {
-  NornFileCoordinator
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn",
-  "version": "0.1.0-tip.35390859630.1",
+  "version": "0.1.0-tip.35568631545.1",
   "description": "TypeScript SDK for building agent-driven and code-driven Norn workflows.",
   "type": "module",
   "license": "MIT",
@@ -26,10 +26,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./files": {
-      "types": "./dist/files.d.ts",
-      "import": "./dist/files.js"
-    },
     "./schema": {
       "types": "./dist/schema.d.ts",
       "import": "./dist/schema.js"

package/dist/agent-resource-adapter.d.ts

@@ -1,12 +0,0 @@
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-export type NornAgentResourceBinding = {
-    readonly tools: readonly ToolDefinition[];
-    dispose(): Promise<void>;
-};
-export type NornAgentResourceAdapter = {
-    readonly name: string;
-    bind(context: {
-        readonly runId: string;
-        readonly label: string;
-    }): Promise<NornAgentResourceBinding>;
-};

package/dist/files.d.ts

@@ -1,17 +0,0 @@
-export declare class NornFileCoordinator {
-    private readonly input;
-    private readonly lockRoot;
-    constructor(input: {
-        readonly lockRoot: string;
-        readonly waitTimeoutMs: number;
-    });
-    withExclusiveLock<T>(path: string, operation: (lockedPath: string) => Promise<T>): Promise<T>;
-    readText(path: string): Promise<string>;
-    writeText(path: string, content: string): Promise<void>;
-    private withCleanup;
-    private resolveTarget;
-    private acquire;
-    private reclaimDeadOwner;
-    private removeEmptyLock;
-}
-export declare function createRunFileCoordinator(runRoot: string): NornFileCoordinator;

package/dist/files.js

@@ -1,162 +0,0 @@
-// ../core/src/atomic-files.ts
-import { randomUUID } from "node:crypto";
-import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-
-// ../core/src/errors.ts
-function isNodeError(error) {
-  return error instanceof Error && "code" in error;
-}
-
-// ../core/src/atomic-files.ts
-async function writeTextAtomically(path, content) {
-  await mkdir(dirname(path), { recursive: true });
-  let existingMode;
-  try {
-    existingMode = (await stat(path)).mode & 511;
-  } catch (error) {
-    if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-  }
-  const tmpPath = `${path}.${randomUUID()}.tmp`;
-  try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
-    if (existingMode !== void 0) await chmod(tmpPath, existingMode);
-    await rename(tmpPath, path);
-  } catch (error) {
-    await rm(tmpPath, { force: true }).catch(() => void 0);
-    throw error;
-  }
-}
-
-// src/files.ts
-import { createHash, randomUUID as randomUUID2 } from "node:crypto";
-import { lstat, mkdir as mkdir2, mkdtemp, readFile, readdir, realpath, rename as rename2, rm as rm2, rmdir, unlink, writeFile as writeFile2 } from "node:fs/promises";
-import { hostname } from "node:os";
-import { basename, dirname as dirname2, join, resolve } from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
-var ownerSchema = Type.Object({
-  token: Type.String({ format: "uuid" }),
-  pid: Type.Integer({ exclusiveMinimum: 0 }),
-  host: Type.String(),
-  target: Type.String()
-}, { additionalProperties: false });
-var NornFileCoordinator = class {
-  constructor(input) {
-    this.input = input;
-    if (!Number.isSafeInteger(input.waitTimeoutMs) || input.waitTimeoutMs <= 0) throw new Error("Lock wait timeout must be a positive integer");
-    this.lockRoot = resolve(input.lockRoot);
-  }
-  input;
-  lockRoot;
-  async withExclusiveLock(path, operation) {
-    const target = await this.resolveTarget(path);
-    await mkdir2(this.lockRoot, { recursive: true, mode: 448 });
-    const key = createHash("sha256").update(target).digest("hex");
-    const lockPath = join(this.lockRoot, `${key}.lock`);
-    const stagingPath = await mkdtemp(join(this.lockRoot, `${key}.pending-`));
-    const token = randomUUID2();
-    const marker = `${token}.json`;
-    return this.withCleanup({
-      operation: async () => {
-        await writeFile2(join(stagingPath, marker), JSON.stringify({ token, pid: process.pid, host: hostname(), target }), { mode: 384 });
-        await this.acquire({ stagingPath, lockPath, target });
-        return this.withCleanup({
-          operation: () => operation(target),
-          cleanup: async () => {
-            await unlink(join(lockPath, marker));
-            await this.removeEmptyLock(lockPath);
-          }
-        });
-      },
-      cleanup: () => rm2(stagingPath, { recursive: true, force: true })
-    });
-  }
-  async readText(path) {
-    return this.withExclusiveLock(path, (lockedPath) => readFile(lockedPath, "utf8"));
-  }
-  async writeText(path, content) {
-    await mkdir2(dirname2(path), { recursive: true });
-    await this.withExclusiveLock(path, (lockedPath) => writeTextAtomically(lockedPath, content));
-  }
-  async withCleanup(input) {
-    let result;
-    try {
-      result = await input.operation();
-    } catch (error) {
-      try {
-        await input.cleanup();
-      } catch (cleanupError) {
-        throw new AggregateError([error, cleanupError], "File operation and lock cleanup failed");
-      }
-      throw error;
-    }
-    await input.cleanup();
-    return result;
-  }
-  async resolveTarget(path) {
-    try {
-      return await realpath(path);
-    } catch (error) {
-      if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-      const entry = await lstat(path).catch((error2) => {
-        if (isNodeError(error2) && error2.code === "ENOENT") return void 0;
-        throw error2;
-      });
-      if (entry?.isSymbolicLink()) throw new Error(`Cannot lock a dangling symbolic link: ${path}`);
-      return join(await realpath(dirname2(path)), basename(path));
-    }
-  }
-  async acquire(input) {
-    const deadline = Date.now() + this.input.waitTimeoutMs;
-    while (true) {
-      try {
-        await rename2(input.stagingPath, input.lockPath);
-        return;
-      } catch (error) {
-        if (!isNodeError(error) || !["ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
-      }
-      await this.reclaimDeadOwner(input);
-      if (Date.now() >= deadline) throw new Error(`Timed out waiting for file lock: ${input.target}`);
-      await delay(10);
-    }
-  }
-  async reclaimDeadOwner(input) {
-    try {
-      const entries = await readdir(input.lockPath);
-      if (entries.length === 0) return;
-      if (entries.length !== 1) throw new Error(`Invalid file lock ownership: ${input.lockPath}`);
-      const marker = entries[0];
-      const owner = Value.Parse(ownerSchema, JSON.parse(await readFile(join(input.lockPath, marker), "utf8")));
-      if (marker !== `${owner.token}.json` || owner.target !== input.target || owner.host !== hostname()) {
-        throw new Error(`Incompatible file lock ownership: ${input.lockPath}`);
-      }
-      try {
-        process.kill(owner.pid, 0);
-        return;
-      } catch (error) {
-        if (isNodeError(error) && error.code === "EPERM") return;
-        if (!isNodeError(error) || error.code !== "ESRCH") throw error;
-      }
-      await unlink(join(input.lockPath, marker));
-      await this.removeEmptyLock(input.lockPath);
-    } catch (error) {
-      if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-    }
-  }
-  async removeEmptyLock(path) {
-    try {
-      await rmdir(path);
-    } catch (error) {
-      if (!isNodeError(error) || !["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
-    }
-  }
-};
-function createRunFileCoordinator(runRoot) {
-  return new NornFileCoordinator({ lockRoot: join(runRoot, "locks"), waitTimeoutMs: 3e4 });
-}
-export {
-  NornFileCoordinator,
-  createRunFileCoordinator
-};

package/dist/resources.d.ts

@@ -1,17 +0,0 @@
-import type { NornFileCoordinator } from "./files.ts";
-import type { NornJsonValue } from "./schema.ts";
-export type NornResourceContext = {
-    readonly mode: "create" | "open";
-    readonly directory: string;
-    readonly files: NornFileCoordinator;
-};
-export type NornResourceDefinition<T> = {
-    readonly name: string;
-    readonly kind: string;
-    readonly configuration: NornJsonValue;
-    initialize(context: NornResourceContext): Promise<T>;
-};
-export type NornResources = {
-    readonly files: NornFileCoordinator;
-    ensure<T>(definition: NornResourceDefinition<T>): Promise<T>;
-};