@vimhead.dev/norn 0.1.0-tip.35359392805.1 → 0.1.0-tip.35436871363.1

package/dist/api.d.ts

@@ -1,5 +1,5 @@
-import type { CreateAgentSessionOptions, EventBus, PromptOptions } from "@earendil-works/pi-coding-agent";
-import { Type, type Static, type StaticDecode, type StaticEncode, type TCodec, type TSchema } from "typebox";
+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";
 export type MaybePromise<T> = T | Promise<T>;
@@ -8,31 +8,37 @@ 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, ParamsSchema extends TSchema = TSchema, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
-    (params: StaticEncode<ParamsSchema>): NornRunNext;
+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;
     readonly isEntrypoint: boolean;
     readonly instructions?: string;
-    readonly params: ParamsSchema;
-    readonly gate?: NornWorkflowAnyGate;
-    readonly isolation: NornWorkflowIsolation<IsolationMode>;
+    readonly args: ArgsSchema;
+    readonly gate?: NornWorkflowGate<ArgsSchema> & {
+        describe?(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<string>;
+    };
+    readonly config?: ConfigSchema;
+    readonly scope: Scope;
+    execute(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
 };
-export type NornAnyWorkflowDeclaration = Pick<NornWorkflowDeclaration, keyof NornWorkflowDeclaration> & ((params: never) => NornRunNext);
-export type NornWorkflowRefSchemaOptions<ParamsSchema extends TSchema = TSchema> = {
-    readonly params?: ParamsSchema;
+export type NornAnyWorkflowDeclaration = Pick<NornWorkflowDeclaration, keyof NornWorkflowDeclaration> & ((args: never) => NornRunNext);
+export type NornWorkflowRefSchemaOptions<ArgsSchema extends TSchema = TSchema> = {
+    readonly args?: ArgsSchema;
 };
 export type NornWorkflowRefInput = StaticEncode<typeof workflowReferenceInputSchema>;
-export type NornWorkflowRefOutput<ParamsSchema extends TSchema> = (params: StaticEncode<ParamsSchema> & object) => NornRunNext;
-export type NornWorkflowParamsInput<TWorkflow extends NornAnyWorkflowDeclaration> = StaticEncode<TWorkflow["params"]>;
-export type NornWorkflowParams<TWorkflow extends NornAnyWorkflowDeclaration> = StaticDecode<TWorkflow["params"]>;
-export type NornWorkflowGate<ParamsSchema extends TSchema> = unknown extends StaticEncode<ParamsSchema> ? NornWorkflowAnyGate : StaticEncode<ParamsSchema> extends Record<string, unknown> ? {
+export type NornWorkflowRefOutput<ArgsSchema extends TSchema> = (args: StaticEncode<ArgsSchema> & object) => NornRunNext;
+export type NornWorkflowArgsInput<TWorkflow extends NornAnyWorkflowDeclaration> = StaticEncode<TWorkflow["args"]>;
+export type NornWorkflowArgs<TWorkflow extends NornAnyWorkflowDeclaration> = StaticDecode<TWorkflow["args"]>;
+export type NornWorkflowGate<ArgsSchema extends TSchema> = unknown extends StaticEncode<ArgsSchema> ? NornWorkflowAnyGate : StaticEncode<ArgsSchema> extends Record<string, unknown> ? {
     readonly enabled: true;
-    readonly fields?: readonly Extract<keyof StaticEncode<ParamsSchema>, string>[];
+    readonly fields?: readonly Extract<keyof StaticEncode<ArgsSchema>, string>[];
 } : {
     readonly enabled: true;
     readonly fields?: never;
@@ -44,98 +50,54 @@ type NornWorkflowInstructions = {
     readonly isEntrypoint: false;
     readonly instructions?: string;
 };
-export type NornWorkflowDefinition<Id extends string | undefined = string | undefined, ParamsSchema extends TSchema = TSchema, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
-    readonly id?: Id;
-    readonly params: ParamsSchema;
-    readonly gate?: NornWorkflowGate<ParamsSchema>;
-    readonly isolation?: NornWorkflowIsolation<IsolationMode>;
-} & NornWorkflowInstructions;
-export type NornAnyWorkflowDefinition = {
-    readonly id?: string;
-    readonly params: TSchema;
-    readonly gate?: NornWorkflowAnyGate;
-    readonly isolation?: NornWorkflowIsolation;
-} & NornWorkflowInstructions;
-export type NornWorkflowStateDefinition<Schema extends TSchema = TSchema, Id extends string = string> = {
-    readonly id: Id;
-    readonly description?: string;
-    readonly schema: Schema;
-};
-export type NornWorkflowStateDefinitionInput<Schema extends TSchema = TSchema, Id extends string | undefined = string | undefined> = {
-    readonly id?: Id;
-    readonly description?: string;
-    readonly schema: Schema;
-};
-export type NornWorkflowPluginWorkflows = Record<string, NornAnyWorkflowDefinition>;
-export type NornWorkflowPluginStateTree = {
-    readonly [key: string]: NornWorkflowPluginStateTreeNode;
-};
-type NornStateSchema = TSchema & ({
-    readonly "~kind": string;
-} | {
-    readonly "~unsafe": unknown;
-});
-export type NornWorkflowPluginStateTreeNode = NornStateSchema | NornWorkflowStateDefinitionInput | NornWorkflowPluginStateTree;
-type JoinPath<Head extends string, Parts extends readonly string[]> = Parts extends readonly [] ? Head : Parts extends readonly [infer First extends string, ...infer Rest extends string[]] ? JoinPath<`${Head}.${First}`, Rest> : string;
-type NornInvalidGateFields<TWorkflow> = TWorkflow extends {
-    readonly params: infer ParamsSchema extends TSchema;
-    readonly gate: {
-        readonly fields: infer Fields extends readonly string[];
+type WorkflowConfig<Schema extends TSchema | undefined> = Schema extends TSchema ? StaticDecode<Schema> : 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 paths: NornWorkflowPaths;
+    readonly run: NornRun;
+} & (Scope extends NornWorkflowScopeInfo ? {
+    readonly scope: {
+        readonly id: Scope["id"];
+        readonly config: WorkflowConfig<Scope["config"]>;
     };
-} ? Exclude<Fields[number], Extract<keyof StaticEncode<ParamsSchema>, string>> : never;
-type NornValidatedWorkflowGate<TWorkflow> = [NornInvalidGateFields<TWorkflow>] extends [never] ? unknown : {
-    readonly gate: {
-        readonly fields: readonly Extract<keyof StaticEncode<TWorkflow extends {
-            readonly params: infer ParamsSchema extends TSchema;
-        } ? ParamsSchema : TSchema>, string>[];
-    };
-};
-export type NornValidatedWorkflowGates<Workflows> = {
-    readonly [Key in keyof Workflows]: NornValidatedWorkflowGate<Workflows[Key]>;
-};
-export type NornQualifiedPluginWorkflow<PluginId extends string, WorkflowKey extends string, TWorkflow extends NornAnyWorkflowDefinition> = TWorkflow extends {
-    readonly params: infer ParamsSchema extends TSchema;
-} ? NornWorkflowDeclaration<TWorkflow extends {
-    readonly id: infer ExplicitId extends string;
-} ? ExplicitId : `${PluginId}.${WorkflowKey}`, ParamsSchema, TWorkflow extends {
-    readonly isolation: {
-        readonly mode: infer IsolationMode extends NornWorkflowIsolationMode;
+} : {});
+export type NornWorkflowDefinition<Id extends string = string, ArgsSchema extends TSchema = TSchema, ConfigSchema extends TSchema | undefined = undefined, Scope extends NornWorkflowScopeInfo | undefined = undefined> = {
+    readonly id: Id;
+    readonly args: ArgsSchema;
+    readonly config?: ConfigSchema;
+    readonly gate?: NornWorkflowGate<ArgsSchema> & {
+        describe?(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<string>;
     };
-} ? IsolationMode : "runWorkspace"> : never;
-export type NornQualifiedPluginWorkflows<PluginId extends string, Workflows extends NornWorkflowPluginWorkflows> = {
-    readonly [Key in keyof Workflows]: NornQualifiedPluginWorkflow<PluginId, Key & string, Workflows[Key]>;
-};
-export type NornQualifiedPluginStates<PluginId extends string, States, Path extends readonly string[] = []> = {
-    readonly [Key in keyof States]: States[Key] extends NornStateSchema ? NornWorkflowStateDefinition<States[Key], JoinPath<PluginId, [...Path, Key & string]>> : States[Key] extends NornWorkflowStateDefinitionInput<infer Schema extends NornStateSchema> ? NornWorkflowStateDefinition<Schema, States[Key] extends {
-        readonly id: infer Id extends string;
-    } ? Id : JoinPath<PluginId, [...Path, Key & string]>> : States[Key] extends NornWorkflowPluginStateTree ? NornQualifiedPluginStates<PluginId, States[Key], [...Path, Key & string]> : never;
+    execute(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
+} & NornWorkflowInstructions;
+export type NornWorkflowScopeInfo = {
+    readonly id: string;
+    readonly config?: TSchema;
 };
-export type NornWorkflowPluginManifest<PluginId extends string = string, ConfigSchema extends TSchema | undefined = TSchema | undefined, Workflows extends Record<string, NornAnyWorkflowDeclaration> = Record<string, NornAnyWorkflowDeclaration>, States = undefined> = {
-    readonly id: PluginId;
-    readonly config?: ConfigSchema;
-    readonly workflows: Workflows;
-    readonly states: States;
-};
-export type NornAnyWorkflowPluginManifest = NornWorkflowPluginManifest<string, TSchema | undefined, Record<string, NornAnyWorkflowDeclaration>, unknown>;
-export type NornWorkflowPluginConfigSchema<TManifest extends NornAnyWorkflowPluginManifest> = TManifest extends {
-    readonly config?: infer ConfigSchema extends TSchema | undefined;
-} ? ConfigSchema : undefined;
-export type NornWorkflowPluginConfig<TManifest extends NornAnyWorkflowPluginManifest> = NornWorkflowPluginConfigSchema<TManifest> extends undefined ? undefined : StaticDecode<NonNullable<NornWorkflowPluginConfigSchema<TManifest>>>;
-export type NornDefinePluginManifestInput<PluginId extends string, ConfigSchema extends TSchema | undefined, Workflows extends NornWorkflowPluginWorkflows, States extends NornWorkflowPluginStateTree | undefined> = {
-    readonly id: PluginId;
+export type NornWorkflowScope<Id extends string, ConfigSchema extends TSchema | undefined> = {
+    readonly id: Id;
+    readonly config: ConfigSchema;
+    workflow<const LocalId extends string, ArgsSchema extends TSchema, LocalConfig extends TSchema | undefined = undefined>(definition: NornWorkflowDefinition<LocalId, ArgsSchema, LocalConfig, {
+        readonly id: Id;
+        readonly config: ConfigSchema;
+    }>): NornWorkflowDeclaration<`${Id}.${LocalId}`, ArgsSchema, LocalConfig, {
+        readonly id: Id;
+        readonly config: ConfigSchema;
+    }>;
+};
+export declare function workflow<const Id extends string, ArgsSchema extends TSchema, ConfigSchema extends TSchema | undefined = undefined>(definition: NornWorkflowDefinition<Id, ArgsSchema, ConfigSchema>): NornWorkflowDeclaration<Id, ArgsSchema, ConfigSchema, undefined>;
+export declare function workflowScope<const Id extends string, ConfigSchema extends TSchema | undefined = undefined>(input: {
+    readonly id: Id;
     readonly config?: ConfigSchema;
-    readonly workflows: Workflows & NornValidatedWorkflowGates<Workflows>;
-    readonly states?: States;
-};
-export declare function definePluginManifest<const PluginId extends string, const ConfigSchema extends TSchema | undefined = undefined, const Workflows extends NornWorkflowPluginWorkflows = NornWorkflowPluginWorkflows, const States extends NornWorkflowPluginStateTree | undefined = undefined>(input: NornDefinePluginManifestInput<PluginId, ConfigSchema, Workflows, States>): NornWorkflowPluginManifest<PluginId, ConfigSchema, NornQualifiedPluginWorkflows<PluginId, Workflows>, States extends NornWorkflowPluginStateTree ? NornQualifiedPluginStates<PluginId, States> : undefined>;
+}): NornWorkflowScope<Id, ConfigSchema>;
 export type NornRunNext = {
     readonly type: "next";
     readonly workflowId: string;
-    readonly params: unknown;
+    readonly args: unknown;
 };
 export type NornRunOutcomeMetadata = {
     readonly summary?: string;
-    readonly artifacts?: Record<string, NornArtifactRef>;
     readonly logs?: Record<string, NornLogRef>;
     readonly data?: Record<string, unknown>;
 };
@@ -149,19 +111,7 @@ export type NornRunFail = {
         readonly summary: string;
     };
 };
-export type NornWorkflowExecutionResult = NornRunNext | NornRunComplete | NornRunFail;
-export type NornRunFor<TWorkflow extends NornAnyWorkflowDeclaration> = TWorkflow extends {
-    readonly isolation: {
-        readonly mode: "project";
-    };
-} ? NornProjectRun : NornRun;
-export type NornWorkflowGateImplementation<TWorkflow extends NornAnyWorkflowDeclaration, TConfig> = {
-    describe(run: NornRunFor<TWorkflow>, params: NornWorkflowParams<TWorkflow>, config: TConfig): MaybePromise<string>;
-};
-export type NornWorkflowImplementation<TWorkflow extends NornAnyWorkflowDeclaration, TConfig = unknown> = {
-    readonly gate?: NornWorkflowGateImplementation<TWorkflow, TConfig>;
-    execute(run: NornRunFor<TWorkflow>, params: NornWorkflowParams<TWorkflow>, config: TConfig): MaybePromise<NornWorkflowExecutionResult>;
-};
+export type WorkflowResult = NornRunNext | NornRunComplete | NornRunFail;
 export type NornRunStartOptions = {
     readonly id?: string;
     readonly name?: string;
@@ -206,7 +156,7 @@ export type NornStoppedRunResult = {
 };
 export type NornRunInterruption = {
     readonly workflowId: string;
-    readonly params: unknown;
+    readonly args: unknown;
     readonly description: string;
     readonly fields?: readonly string[];
 };
@@ -239,6 +189,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;
@@ -261,46 +212,19 @@ export type NornRunCheckpoint = {
     readonly message: string;
     readonly createdAt: string;
 };
-export type NornWorkflowStateReader = {
-    get<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema>>;
-    getOptional<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined>;
-};
-export type NornWorkflowState = NornWorkflowStateReader & {
-    set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void>;
-};
-export type NornWorkflowPluginContext = {
-    readonly cwd: string;
-    readonly state: NornWorkflowState;
-};
-export type NornWorkflowPluginImplementation<TManifest extends NornAnyWorkflowPluginManifest> = {
-    readonly workflows: {
-        readonly [Key in keyof TManifest["workflows"]]: NornWorkflowImplementation<TManifest["workflows"][Key], NornWorkflowPluginConfig<TManifest>>;
-    };
-};
-export type NornWorkflowPluginImplementationFactory<TManifest extends NornAnyWorkflowPluginManifest> = (context: NornWorkflowPluginContext) => NornWorkflowPluginImplementation<TManifest>;
-export type NornWorkflowPluginImplementationInput<TManifest extends NornAnyWorkflowPluginManifest> = NornWorkflowPluginImplementation<TManifest> | NornWorkflowPluginImplementationFactory<TManifest>;
-export type NornWorkflowPlugin<TManifest extends NornAnyWorkflowPluginManifest = NornAnyWorkflowPluginManifest> = {
-    readonly manifest: TManifest;
-    readonly implementation: NornWorkflowPluginImplementationInput<TManifest>;
-};
-export declare function definePlugin<TManifest extends NornAnyWorkflowPluginManifest>(manifest: TManifest, implementation: NornWorkflowPluginImplementationInput<TManifest>): NornWorkflowPlugin<TManifest>;
 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 emptyWorkflowRefParamsSchema: Type.TObject<{}>;
+declare const emptyWorkflowRefArgsSchema: Type.TObject<{}>;
 declare const workflowReferenceInputSchema: Type.TUnion<[Type.TString, Type.TObject<{
     workflow: Type.TString;
-    forwardParams: Type.TRecord<"^.*$", Type.TUnknown>;
+    forwardArgs: Type.TRecord<"^.*$", Type.TUnknown>;
 }>]>;
-export declare function workflowRefSchema<ParamsSchema extends TSchema = typeof emptyWorkflowRefParamsSchema>(options?: NornWorkflowRefSchemaOptions<ParamsSchema>): TCodec<typeof workflowReferenceInputSchema, NornWorkflowRefOutput<ParamsSchema>>;
+export declare function workflowRefSchema<ArgsSchema extends TSchema = typeof emptyWorkflowRefArgsSchema>(options?: NornWorkflowRefSchemaOptions<ArgsSchema>): TCodec<typeof workflowReferenceInputSchema, NornWorkflowRefOutput<ArgsSchema>>;
 export type NornLogRef = {
     readonly id: string;
 };
@@ -319,9 +243,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"];
@@ -433,27 +357,13 @@ 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, params: unknown): NornRunNext;
+    next(workflowId: string, args: unknown): NornRunNext;
     complete(metadata?: NornRunOutcomeMetadata): NornRunComplete;
     fail(metadata: NornRunOutcomeMetadata & {
         readonly summary: string;
     }): NornRunFail;
-    resources: import("./resources.ts").NornResources;
-    state: NornWorkflowState;
-    artifacts: {
-        write(path: string, content: string): Promise<NornArtifactRef>;
-        read(ref: NornArtifactRef): Promise<string>;
-    };
     logs: {
         read(log: NornLogRef): Promise<string>;
     };
@@ -465,10 +375,9 @@ type NornRunBase = {
         prompt<ResponseSchema extends TSchema>(input: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
     };
 };
-export type NornWorkflowPluginInfo = {
-    readonly id: string;
-    readonly path?: string;
-    readonly configPath?: string;
+export type NornWorkflowSource = {
+    readonly path: string;
+    readonly configPath: string;
 };
 export type NornJsonSchema = Record<string, unknown>;
 export type NornWorkflowGateInfo = {
@@ -479,25 +388,34 @@ export type NornRegisteredWorkflowInfo = {
     readonly id: string;
     readonly instructions?: string;
     readonly isEntrypoint: boolean;
-    readonly isolation: NornWorkflowIsolation;
-    readonly plugin?: NornWorkflowPluginInfo;
+    readonly scope?: {
+        readonly id: string;
+    };
+    readonly source?: NornWorkflowSource;
+    readonly configKey: string;
 };
 export type NornInspectedWorkflowInfo = NornRegisteredWorkflowInfo & {
-    readonly paramsSchema: NornJsonSchema;
+    readonly scope?: {
+        readonly id: string;
+        readonly configKey: string;
+        readonly configSchema: NornJsonSchema | null;
+    };
+    readonly argsSchema: NornJsonSchema;
+    readonly configSchema: NornJsonSchema | null;
     readonly gate: NornWorkflowGateInfo | null;
 };
-export type NornPluginDiagnostic = {
+export type NornWorkflowDiagnostic = {
     readonly configPath: string;
-    readonly pluginPath: string;
-    readonly pluginId: string | null;
+    readonly modulePath: string;
+    readonly scopeId: string | null;
     readonly workflowId: string | null;
-    readonly stage: "import" | "declaration" | "config" | "implementation" | "duplicate" | "schema";
+    readonly stage: "import" | "declaration" | "config" | "duplicate" | "schema";
     readonly message: string;
     readonly issues: readonly TLocalizedValidationError[];
 };
 export type NornProjectLoadStatus = {
     readonly isComplete: boolean;
-    readonly diagnostics: readonly NornPluginDiagnostic[];
+    readonly diagnostics: readonly NornWorkflowDiagnostic[];
 };
 export type NornWorkflowCatalogInfo = NornProjectLoadStatus & {
     readonly workflows: readonly NornRegisteredWorkflowInfo[];
@@ -508,7 +426,9 @@ export type NornWorkflowInspection = NornProjectLoadStatus & {
 export type NornProjectInspection = NornProjectLoadStatus & {
     readonly project: NornProjectInfo;
 };
-export type NornProjectPluginInfo = NornWorkflowPluginInfo & {
+export type NornProjectConfigurationInfo = {
+    readonly key: string;
+    readonly scopeId: string | null;
     readonly configSchema: NornJsonSchema | null;
     readonly config: unknown;
 };
@@ -519,11 +439,10 @@ export type NornProjectInfo = {
     readonly configPath: string;
     readonly configRoot: string;
     readonly configFiles: readonly string[];
-    readonly plugins: readonly NornProjectPluginInfo[];
+    readonly configurations: readonly NornProjectConfigurationInfo[];
+    readonly modules: readonly NornWorkflowSource[];
 };
 export declare function isWorkflowDeclaration(value: unknown): value is NornAnyWorkflowDeclaration;
-export declare function isWorkflowPlugin(value: unknown): value is NornWorkflowPlugin;
-export declare function isWorkflowPluginManifest(value: unknown): value is NornAnyWorkflowPluginManifest;
 export declare function isWorkflowNext(value: unknown): value is NornRunNext;
 export declare function isWorkflowComplete(value: unknown): value is NornRunComplete;
 export declare function isWorkflowFail(value: unknown): value is NornRunFail;

package/dist/api.js

@@ -4,103 +4,65 @@ import { Type } from "typebox";
 // ../core/src/workflow-transition.ts
 function createWorkflowTransition(input) {
   if (typeof input.workflowId !== "string" || input.workflowId.trim().length === 0) throw new Error("Workflow transition requires a nonempty workflow ID");
-  return { type: "next", workflowId: input.workflowId, params: input.params };
+  return { type: "next", workflowId: input.workflowId, args: input.args };
 }
 
 // src/api.ts
 import { Value } from "typebox/value";
-import { isPlainObject, jsonValueSchema } from "./schema.js";
+import { assertWorkflowMetadata, isPlainObject, jsonValueSchema } from "./schema.js";
 var WORKFLOW_DECLARATION_KIND = "norn.workflow";
-function definePluginManifest(input) {
-  assertLocalDeclarationId(input.id, "plugin");
-  const declaredIds = /* @__PURE__ */ new Set();
-  const workflows = Object.fromEntries(
-    Object.entries(input.workflows).map(([key, workflow]) => [key, qualifyWorkflow(input.id, key, workflow, declaredIds)])
-  );
+function workflow(definition) {
+  return createWorkflow({ definition, 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, {
+    kind: WORKFLOW_DECLARATION_KIND,
+    scope
+  });
+  if (!isWorkflowDeclaration(result)) throw new Error(`Invalid workflow definition: ${definition.id}`);
+  assertWorkflowMetadata(result);
+  return result;
+}
+function workflowScope(input) {
+  assertDeclarationId(input.id);
+  const scope = { id: input.id, config: input.config };
   return {
     id: input.id,
     config: input.config,
-    workflows,
-    states: qualifyStateTree(input.id, input.states, [], declaredIds)
+    workflow(definition) {
+      assertDeclarationId(definition.id);
+      return createWorkflow({ definition: { ...definition, id: `${input.id}.${definition.id}` }, scope });
+    }
   };
 }
-function definePlugin(manifest, implementation) {
-  return { manifest, implementation };
-}
-var artifactRefSchema = Type.Object({
-  path: Type.String()
-});
-var emptyWorkflowRefParamsSchema = Type.Object({});
+var emptyWorkflowRefArgsSchema = Type.Object({});
 var workflowReferenceInputSchema = Type.Union([
   Type.String({ minLength: 1 }),
-  Type.Object({ workflow: Type.String({ minLength: 1 }), forwardParams: Type.Record(Type.String(), Type.Unknown()) })
+  Type.Object({ workflow: Type.String({ minLength: 1 }), forwardArgs: Type.Record(Type.String(), Type.Unknown()) })
 ]);
 function workflowRefSchema(options) {
-  const contributionSchema = options?.params ?? emptyWorkflowRefParamsSchema;
+  const contributionSchema = options?.args ?? emptyWorkflowRefArgsSchema;
   return Type.With(Type.Decode(workflowReferenceInputSchema, (reference) => {
     const workflowId = typeof reference === "string" ? reference : reference.workflow;
-    const forwardParams = typeof reference === "string" ? {} : reference.forwardParams;
-    return (params) => {
-      Value.Assert(contributionSchema, params);
-      if (!isPlainObject(params)) throw new Error("Workflow reference contributions must be objects");
-      Value.Assert(jsonValueSchema, params);
-      return createWorkflowTransition({ workflowId, params: { ...forwardParams, ...params } });
+    const forwardArgs = typeof reference === "string" ? {} : reference.forwardArgs;
+    return (args) => {
+      Value.Assert(contributionSchema, args);
+      if (!isPlainObject(args)) throw new Error("Workflow reference contributions must be objects");
+      Value.Assert(jsonValueSchema, args);
+      return createWorkflowTransition({ workflowId, args: { ...forwardArgs, ...args } });
     };
-  }), { "x-norn-workflow-ref": { contributedParamsSchema: contributionSchema } });
-}
-function assertLocalDeclarationId(id, kind) {
-  if (id.length === 0) throw new Error(`Workflow ${kind} id must not be empty`);
-  if (id.includes(".")) throw new Error(`Workflow ${kind} id must not contain dots: ${id}`);
-}
-function resolveDeclarationId(pluginId, path, explicitId, kind, declaredIds) {
-  for (const segment of path) assertLocalDeclarationId(segment, kind);
-  const id = explicitId ?? [pluginId, ...path].join(".");
-  if (explicitId !== void 0) assertPluginQualifiedId(pluginId, explicitId, kind);
-  if (declaredIds.has(id)) throw new Error(`Duplicate Norn ${kind} id: ${id}`);
-  declaredIds.add(id);
-  return id;
-}
-function assertPluginQualifiedId(pluginId, id, kind) {
-  if (!id.startsWith(`${pluginId}.`)) throw new Error(`Explicit Norn ${kind} id must start with ${pluginId}.: ${id}`);
-  if (id.length === pluginId.length + 1) throw new Error(`Explicit Norn ${kind} id must not be empty after ${pluginId}.`);
+  }), { "x-norn-workflow-ref": { contributedArgsSchema: contributionSchema } });
 }
-function qualifyWorkflow(pluginId, key, workflow, declaredIds) {
-  const id = resolveDeclarationId(pluginId, [key], workflow.id, "workflow", declaredIds);
-  const declaration = (params) => createWorkflowTransition({ workflowId: id, params });
-  return Object.assign(declaration, { ...workflow, kind: WORKFLOW_DECLARATION_KIND, id, isolation: workflow.isolation ?? { mode: "runWorkspace" } });
-}
-function qualifyStateTree(pluginId, node, path, declaredIds) {
-  if (node === void 0) return void 0;
-  if (isTypeboxSchema(node)) return { id: resolveDeclarationId(pluginId, path, void 0, "state", declaredIds), schema: node };
-  if (path.length > 0 && isWorkflowStateDefinitionInput(node)) {
-    return { ...node, id: resolveDeclarationId(pluginId, path, node.id, "state", declaredIds) };
-  }
-  if (!isPlainObject(node)) throw new Error(`Invalid state declaration: ${[pluginId, ...path].join(".")}`);
-  return Object.fromEntries(Object.entries(node).map(([key, child]) => [key, qualifyStateTree(pluginId, child, [...path, key], declaredIds)]));
+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 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.params) && (candidate.isolation?.mode === "runWorkspace" || candidate.isolation?.mode === "project");
-}
-function isTypeboxSchema(value) {
-  return Type.IsUnsafe(value) || Boolean(value && typeof value === "object" && "~kind" in value && typeof value["~kind"] === "string");
-}
-function isWorkflowStateDefinitionInput(value) {
-  if (!isPlainObject(value)) return false;
-  return (value.id === void 0 || typeof value.id === "string") && isTypeboxSchema(value.schema);
-}
-function isWorkflowPlugin(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return isWorkflowPluginManifest(candidate.manifest) && Boolean(candidate.implementation);
-}
-function isWorkflowPluginManifest(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  if (typeof candidate.id !== "string" || candidate.id.length === 0) return false;
-  if (!candidate.workflows || typeof candidate.workflows !== "object") return false;
-  return Object.values(candidate.workflows).every(isWorkflowDeclaration);
+  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;
@@ -118,14 +80,11 @@ function isWorkflowFail(value) {
   return candidate.type === "fail" && typeof candidate.metadata?.summary === "string" && candidate.metadata.summary.length > 0;
 }
 export {
-  artifactRefSchema,
-  definePlugin,
-  definePluginManifest,
   isWorkflowComplete,
   isWorkflowDeclaration,
   isWorkflowFail,
   isWorkflowNext,
-  isWorkflowPlugin,
-  isWorkflowPluginManifest,
-  workflowRefSchema
+  workflow,
+  workflowRefSchema,
+  workflowScope
 };

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";
-export * from "./state-adapter.ts";

package/dist/index.js

@@ -1,9 +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 * from "./state-adapter.js";
-export {
-  NornFileCoordinator
-};

package/dist/schema.js

@@ -23,9 +23,9 @@ function assertWorkflowReferenceAnnotations(schema) {
   if (!isPlainObject(schema)) return;
   if (Object.hasOwn(schema, "x-norn-workflow-ref")) {
     const annotation = schema["x-norn-workflow-ref"];
-    if (!isPlainObject(annotation) || !Object.hasOwn(annotation, "contributedParamsSchema")) throw new Error("Invalid workflow reference annotation");
-    Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], annotation.contributedParamsSchema);
-    assertWorkflowReferenceAnnotations(annotation.contributedParamsSchema);
+    if (!isPlainObject(annotation) || !Object.hasOwn(annotation, "contributedArgsSchema")) throw new Error("Invalid workflow reference annotation");
+    Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], annotation.contributedArgsSchema);
+    assertWorkflowReferenceAnnotations(annotation.contributedArgsSchema);
   }
   for (const keyword of ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]) {
     const schemas = schema[keyword];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn",
-  "version": "0.1.0-tip.35359392805.1",
+  "version": "0.1.0-tip.35436871363.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>;
-};

package/dist/state-adapter.d.ts

@@ -1,10 +0,0 @@
-import type { NornAgentResourceAdapter } from "./agent-resource-adapter.ts";
-import type { NornWorkflowState, NornWorkflowStateDefinition } from "./api.ts";
-export type NornStateFieldAccess = {
-    readonly field: NornWorkflowStateDefinition;
-    readonly access: "read" | "write" | "read-write";
-};
-export declare function StateAdapter(input: {
-    readonly state: NornWorkflowState;
-    readonly fields: readonly NornStateFieldAccess[];
-}): NornAgentResourceAdapter;

package/dist/state-adapter.js

@@ -1,70 +0,0 @@
-// src/state-adapter.ts
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { createHash } from "node:crypto";
-import { Type } from "typebox";
-import { inspectSchema } from "./schema.js";
-var pageParameters = {
-  offset: Type.Integer({ minimum: 0, description: "Zero-based UTF-16 offset into the serialized JSON. Start at 0." }),
-  limit: Type.Integer({ minimum: 1, maximum: 1e4 })
-};
-function StateAdapter(input) {
-  const fields = new Map(input.fields.map((grant) => [grant.field.id, grant]));
-  if (fields.size !== input.fields.length || fields.size === 0) throw new Error("State attachment requires unique, explicitly selected fields");
-  const selectField = (key, access) => {
-    const grant = fields.get(key);
-    if (!grant || grant.access !== access && grant.access !== "read-write") throw new Error(`State ${access} is not attached: ${key}`);
-    return grant.field;
-  };
-  return {
-    name: "norn.state",
-    async bind() {
-      return {
-        tools: [
-          defineTool({
-            name: "norn_state_list",
-            label: "Attached workflow state",
-            description: "List only attached workflow-state field IDs, permissions and value schemas. JSON is paginated; use nextOffset until null.",
-            parameters: Type.Object(pageParameters),
-            async execute(_id, params) {
-              return serializePage({ value: [...fields.values()].map(({ field, access }) => ({ id: field.id, access, schema: inspectSchema(field.schema) })), ...params });
-            }
-          }),
-          defineTool({
-            name: "norn_state_get",
-            label: "Read workflow state",
-            description: "Read a selected workflow-state field. Unset fields return isSet:false. JSON is paginated; concurrent writes can change later pages, so compare revision before combining pages.",
-            parameters: Type.Object({ key: Type.String(), ...pageParameters }),
-            async execute(_id, params) {
-              const value = await input.state.getOptional(selectField(params.key, "read"));
-              return serializePage({ value: value === void 0 ? { isSet: false } : { isSet: true, value }, ...params });
-            }
-          }),
-          defineTool({
-            name: "norn_state_set",
-            label: "Write workflow state",
-            description: "Set an explicitly writable workflow-state field. Validate the value against its schema from norn_state_list. A get followed by set is not a transaction.",
-            parameters: Type.Object({ key: Type.String(), value: Type.Unknown() }),
-            async execute(_id, params, signal) {
-              signal?.throwIfAborted();
-              const field = selectField(params.key, "write");
-              await input.state.set(field, params.value);
-              return { content: [{ type: "text", text: "Workflow state saved." }], details: {} };
-            }
-          })
-        ],
-        async dispose() {
-        }
-      };
-    }
-  };
-}
-function serializePage(input) {
-  const serialized = JSON.stringify(input.value);
-  if (!Number.isInteger(input.offset) || input.offset < 0 || !Number.isInteger(input.limit) || input.limit < 1 || input.limit > 1e4) throw new Error("Invalid state output page");
-  const end = Math.min(serialized.length, input.offset + input.limit);
-  const details = { text: serialized.slice(input.offset, end), nextOffset: end < serialized.length ? end : null, revision: createHash("sha256").update(serialized).digest("hex") };
-  return { content: [{ type: "text", text: JSON.stringify(details) }], details };
-}
-export {
-  StateAdapter
-};