@vimhead.dev/norn 0.1.0-tip.35240723931.1 → 0.1.0-tip.35343816255.1

package/dist/api.d.ts

@@ -1,6 +1,6 @@
 import type { CreateAgentSessionOptions, EventBus, PromptOptions } from "@earendil-works/pi-coding-agent";
-import { z } from "zod";
-import type { NornResolvedSeerModeConfig } from "./seer/config.ts";
+import { Type, type Static, 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>;
 export type NornDispose = () => void;
@@ -12,47 +12,27 @@ export type NornWorkflowIsolationMode = "runWorkspace" | "project";
 export type NornWorkflowIsolation<Mode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
     readonly mode: Mode;
 };
-declare const nornWorkflowRefParamsBrand: unique symbol;
-declare const nornWorkflowRefForwardParamsBrand: unique symbol;
-type NornWorkflowRefForwardParams = Record<string, unknown> & {
-    readonly [nornWorkflowRefForwardParamsBrand]: true;
-};
-export type NornWorkflowRef<ParamsSchema extends z.ZodType = z.ZodType, Id extends string = string, ForwardParams = unknown> = Id & {
-    readonly [nornWorkflowRefParamsBrand]: (params: z.input<ParamsSchema> & ForwardParams) => z.input<ParamsSchema> & ForwardParams;
-};
-export type NornWorkflowDeclaration<Id extends string = string, ParamsSchema extends z.ZodType = z.ZodType, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
+export type NornWorkflowDeclaration<Id extends string = string, ParamsSchema extends TSchema = TSchema, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
+    (params: StaticEncode<ParamsSchema>): NornRunNext;
     readonly kind: typeof WORKFLOW_DECLARATION_KIND;
-    readonly id: NornWorkflowRef<ParamsSchema, Id>;
+    readonly id: Id;
     readonly isEntrypoint: boolean;
     readonly instructions?: string;
     readonly params: ParamsSchema;
     readonly gate?: NornWorkflowAnyGate;
     readonly isolation: NornWorkflowIsolation<IsolationMode>;
 };
-export type NornAnyWorkflowDeclaration = NornWorkflowDeclaration<string, z.ZodType<any, any>>;
-export type NornWorkflowTarget<ParamsSchema extends z.ZodType = z.ZodType> = NornWorkflowDeclaration<string, ParamsSchema> | NornWorkflowRef<ParamsSchema>;
-export type NornWorkflowRefSchemaInput<ParamsSchema extends z.ZodType = z.ZodType> = string | {
-    readonly id: NornWorkflowRef<ParamsSchema>;
-    readonly workflow?: never;
-    readonly forwardParams?: never;
-};
-export type NornWorkflowRefSchemaOptions<ParamsSchema extends z.ZodType = z.ZodType> = {
+export type NornAnyWorkflowDeclaration = Pick<NornWorkflowDeclaration, keyof NornWorkflowDeclaration> & ((params: never) => NornRunNext);
+export type NornWorkflowRefSchemaOptions<ParamsSchema extends TSchema = TSchema> = {
     readonly params?: ParamsSchema;
 };
-export type NornWorkflowRefInput<ParamsSchema extends z.ZodType> = NornWorkflowRefSchemaInput<ParamsSchema> | {
-    readonly workflow: NornWorkflowRefSchemaInput<z.ZodType<any, any>>;
-    readonly forwardParams: Record<string, unknown>;
-};
-export type NornWorkflowRefOutput<ParamsSchema extends z.ZodType> = {
-    readonly workflow: NornWorkflowRef<ParamsSchema, string, NornWorkflowRefForwardParams>;
-    readonly forwardParams: NornWorkflowRefForwardParams;
-};
-export type NornWorkflowParamsInput<TWorkflow extends NornAnyWorkflowDeclaration> = z.input<TWorkflow["params"]>;
-export type NornWorkflowParams<TWorkflow extends NornAnyWorkflowDeclaration> = z.output<TWorkflow["params"]>;
-export type NornWorkflowTargetParamsInput<TWorkflow extends NornWorkflowTarget<any>> = TWorkflow extends NornWorkflowDeclaration<string, infer ParamsSchema> ? z.input<ParamsSchema> : TWorkflow extends NornWorkflowRef<infer ParamsSchema, string, infer ForwardParams> ? z.input<ParamsSchema> & ForwardParams : never;
-export type NornWorkflowGate<ParamsSchema extends z.ZodType> = unknown extends z.input<ParamsSchema> ? NornWorkflowAnyGate : z.input<ParamsSchema> extends Record<string, unknown> ? {
+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> ? {
     readonly enabled: true;
-    readonly fields?: readonly Extract<keyof z.input<ParamsSchema>, string>[];
+    readonly fields?: readonly Extract<keyof StaticEncode<ParamsSchema>, string>[];
 } : {
     readonly enabled: true;
     readonly fields?: never;
@@ -64,7 +44,7 @@ type NornWorkflowInstructions = {
     readonly isEntrypoint: false;
     readonly instructions?: string;
 };
-export type NornWorkflowDefinition<Id extends string | undefined = string | undefined, ParamsSchema extends z.ZodType = z.ZodType, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
+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>;
@@ -72,44 +52,49 @@ export type NornWorkflowDefinition<Id extends string | undefined = string | unde
 } & NornWorkflowInstructions;
 export type NornAnyWorkflowDefinition = {
     readonly id?: string;
-    readonly params: z.ZodType;
+    readonly params: TSchema;
     readonly gate?: NornWorkflowAnyGate;
     readonly isolation?: NornWorkflowIsolation;
 } & NornWorkflowInstructions;
-export type NornWorkflowStateDefinition<T = unknown, Id extends string = string> = {
+export type NornWorkflowStateDefinition<Schema extends TSchema = TSchema, Id extends string = string> = {
     readonly id: Id;
     readonly description?: string;
-    readonly schema: z.ZodType<T>;
+    readonly schema: Schema;
 };
-export type NornWorkflowStateDefinitionInput<T = unknown, Id extends string | undefined = string | undefined> = {
+export type NornWorkflowStateDefinitionInput<Schema extends TSchema = TSchema, Id extends string | undefined = string | undefined> = {
     readonly id?: Id;
     readonly description?: string;
-    readonly schema: z.ZodType<T>;
+    readonly schema: Schema;
 };
 export type NornWorkflowPluginWorkflows = Record<string, NornAnyWorkflowDefinition>;
 export type NornWorkflowPluginStateTree = {
     readonly [key: string]: NornWorkflowPluginStateTreeNode;
 };
-export type NornWorkflowPluginStateTreeNode = z.ZodType | NornWorkflowStateDefinitionInput | NornWorkflowPluginStateTree;
+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 z.ZodType;
+    readonly params: infer ParamsSchema extends TSchema;
     readonly gate: {
         readonly fields: infer Fields extends readonly string[];
     };
-} ? Exclude<Fields[number], Extract<keyof z.input<ParamsSchema>, string>> : never;
+} ? Exclude<Fields[number], Extract<keyof StaticEncode<ParamsSchema>, string>> : never;
 type NornValidatedWorkflowGate<TWorkflow> = [NornInvalidGateFields<TWorkflow>] extends [never] ? unknown : {
     readonly gate: {
-        readonly fields: readonly Extract<keyof z.input<TWorkflow extends {
-            readonly params: infer ParamsSchema extends z.ZodType;
-        } ? ParamsSchema : z.ZodType>, string>[];
+        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 z.ZodType;
+    readonly params: infer ParamsSchema extends TSchema;
 } ? NornWorkflowDeclaration<TWorkflow extends {
     readonly id: infer ExplicitId extends string;
 } ? ExplicitId : `${PluginId}.${WorkflowKey}`, ParamsSchema, TWorkflow extends {
@@ -121,28 +106,28 @@ export type NornQualifiedPluginWorkflows<PluginId extends string, Workflows exte
     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 z.ZodType ? NornWorkflowStateDefinition<z.output<States[Key]>, JoinPath<PluginId, [...Path, Key & string]>> : States[Key] extends NornWorkflowStateDefinitionInput<infer Value> ? NornWorkflowStateDefinition<Value, States[Key] extends {
-        readonly id: infer ExplicitId extends string;
-    } ? ExplicitId : JoinPath<PluginId, [...Path, Key & string]>> : States[Key] extends NornWorkflowPluginStateTree ? NornQualifiedPluginStates<PluginId, States[Key], [...Path, Key & string]> : never;
+    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;
 };
-export type NornWorkflowPluginManifest<PluginId extends string = string, ConfigSchema extends z.ZodType | undefined = z.ZodType | undefined, Workflows extends Record<string, NornAnyWorkflowDeclaration> = Record<string, NornAnyWorkflowDeclaration>, States = undefined> = {
+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, z.ZodType | undefined, Record<string, NornAnyWorkflowDeclaration>, unknown>;
+export type NornAnyWorkflowPluginManifest = NornWorkflowPluginManifest<string, TSchema | undefined, Record<string, NornAnyWorkflowDeclaration>, unknown>;
 export type NornWorkflowPluginConfigSchema<TManifest extends NornAnyWorkflowPluginManifest> = TManifest extends {
-    readonly config?: infer ConfigSchema extends z.ZodType | undefined;
+    readonly config?: infer ConfigSchema extends TSchema | undefined;
 } ? ConfigSchema : undefined;
-export type NornWorkflowPluginConfig<TManifest extends NornAnyWorkflowPluginManifest> = NonNullable<NornWorkflowPluginConfigSchema<TManifest>> extends z.ZodType ? z.output<NonNullable<NornWorkflowPluginConfigSchema<TManifest>>> : undefined;
-export type NornDefinePluginManifestInput<PluginId extends string, ConfigSchema extends z.ZodType | undefined, Workflows extends NornWorkflowPluginWorkflows, States extends NornWorkflowPluginStateTree | 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;
     readonly config?: ConfigSchema;
     readonly workflows: Workflows & NornValidatedWorkflowGates<Workflows>;
     readonly states?: States;
 };
-export declare function definePluginManifest<const PluginId extends string, const ConfigSchema extends z.ZodType | 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>;
+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>;
 export type NornRunNext = {
     readonly type: "next";
     readonly workflowId: string;
@@ -277,11 +262,11 @@ export type NornRunCheckpoint = {
     readonly createdAt: string;
 };
 export type NornWorkflowStateReader = {
-    get<T>(state: NornWorkflowStateDefinition<T>): Promise<T>;
-    getOptional<T>(state: NornWorkflowStateDefinition<T>): Promise<T | undefined>;
+    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<T>(state: NornWorkflowStateDefinition<T>, value: T): Promise<void>;
+    set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void>;
 };
 export type NornWorkflowPluginContext = {
     readonly cwd: string;
@@ -306,16 +291,16 @@ export type NornCommandRunInput = {
     readonly env?: Record<string, string>;
     readonly timeoutMs?: number;
 };
-export declare const artifactRefSchema: z.ZodObject<{
-    path: z.ZodString;
-}, z.core.$strip>;
-export type NornArtifactRef = z.output<typeof artifactRefSchema>;
-declare const emptyWorkflowRefParamsSchema: z.ZodObject<{}, z.core.$strip>;
-export declare function workflowRefSchema(): z.ZodType<NornWorkflowRefOutput<typeof emptyWorkflowRefParamsSchema>, NornWorkflowRefInput<typeof emptyWorkflowRefParamsSchema>>;
-export declare function workflowRefSchema(options: {
-    readonly params?: undefined;
-}): z.ZodType<NornWorkflowRefOutput<typeof emptyWorkflowRefParamsSchema>, NornWorkflowRefInput<typeof emptyWorkflowRefParamsSchema>>;
-export declare function workflowRefSchema<ParamsSchema extends z.ZodType>(options: NornWorkflowRefSchemaOptions<ParamsSchema>): z.ZodType<NornWorkflowRefOutput<ParamsSchema>, NornWorkflowRefInput<ParamsSchema>>;
+export declare const artifactRefSchema: Type.TObject<{
+    path: Type.TString;
+}>;
+export type NornArtifactRef = StaticDecode<typeof artifactRefSchema>;
+declare const emptyWorkflowRefParamsSchema: Type.TObject<{}>;
+declare const workflowReferenceInputSchema: Type.TUnion<[Type.TString, Type.TObject<{
+    workflow: Type.TString;
+    forwardParams: Type.TRecord<"^.*$", Type.TUnknown>;
+}>]>;
+export declare function workflowRefSchema<ParamsSchema extends TSchema = typeof emptyWorkflowRefParamsSchema>(options?: NornWorkflowRefSchemaOptions<ParamsSchema>): TCodec<typeof workflowReferenceInputSchema, NornWorkflowRefOutput<ParamsSchema>>;
 export type NornLogRef = {
     readonly id: string;
 };
@@ -344,13 +329,13 @@ export type NornAgentCreateSessionInput = {
     readonly systemPrompt?: string;
     readonly appendSystemPrompt?: readonly string[];
 };
-export type NornAgentPromptInput<ResponseSchema extends z.ZodType> = {
+export type NornAgentPromptInput<ResponseSchema extends TSchema> = {
     readonly prompt: string;
     readonly response: ResponseSchema;
     readonly maxAttempts?: number;
     readonly options?: PromptOptions;
 };
-export type NornAgentSinglePromptInput<ResponseSchema extends z.ZodType> = NornAgentCreateSessionInput & NornAgentPromptInput<ResponseSchema>;
+export type NornAgentSinglePromptInput<ResponseSchema extends TSchema> = NornAgentCreateSessionInput & NornAgentPromptInput<ResponseSchema>;
 export type NornAgentSessionEvents = EventBus;
 export type NornAgentUsageCost = {
     readonly input: number;
@@ -426,10 +411,10 @@ export type NornAgentRunRawAttempt = {
     readonly sessionFile?: string;
     readonly error?: string;
 };
-export type NornAgentRunResult<ResponseSchema extends z.ZodType> = {
+export type NornAgentRunResult<ResponseSchema extends TSchema> = {
     readonly label: string;
     readonly cwd: string;
-    readonly response: z.output<ResponseSchema>;
+    readonly response: StaticDecode<ResponseSchema>;
     readonly usage: NornAgentUsage;
     readonly raw: {
         readonly text: string;
@@ -445,7 +430,7 @@ export type NornAgentSession = {
     readonly label: string;
     readonly cwd: string;
     readonly events: NornAgentSessionEvents;
-    prompt<ResponseSchema extends z.ZodType>(input: NornAgentPromptInput<ResponseSchema>): Promise<z.output<ResponseSchema>>;
+    prompt<ResponseSchema extends TSchema>(input: NornAgentPromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
     dispose(): Promise<void>;
 };
 export type NornRun = NornRunBase;
@@ -458,7 +443,7 @@ type NornRunBase = {
     workspace: string;
     cwd: string;
     path(relativePath: string): string;
-    next<TWorkflow extends NornWorkflowTarget<any>>(workflow: TWorkflow, params: NornWorkflowTargetParamsInput<TWorkflow>): NornRunNext;
+    next(workflowId: string, params: unknown): NornRunNext;
     complete(metadata?: NornRunOutcomeMetadata): NornRunComplete;
     fail(metadata: NornRunOutcomeMetadata & {
         readonly summary: string;
@@ -477,7 +462,7 @@ type NornRunBase = {
     };
     agents: {
         createSession(input: NornAgentCreateSessionInput): Promise<NornAgentSession>;
-        prompt<ResponseSchema extends z.ZodType>(input: NornAgentSinglePromptInput<ResponseSchema>): Promise<z.output<ResponseSchema>>;
+        prompt<ResponseSchema extends TSchema>(input: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
     };
 };
 export type NornWorkflowPluginInfo = {
@@ -508,11 +493,7 @@ export type NornPluginDiagnostic = {
     readonly workflowId: string | null;
     readonly stage: "import" | "declaration" | "config" | "implementation" | "duplicate" | "schema";
     readonly message: string;
-    readonly issues: readonly {
-        readonly path: readonly (string | number)[];
-        readonly code: string;
-        readonly message: string;
-    }[];
+    readonly issues: readonly TLocalizedValidationError[];
 };
 export type NornProjectLoadStatus = {
     readonly isComplete: boolean;
@@ -539,7 +520,6 @@ export type NornProjectInfo = {
     readonly configRoot: string;
     readonly configFiles: readonly string[];
     readonly plugins: readonly NornProjectPluginInfo[];
-    readonly seerMode: NornResolvedSeerModeConfig | null;
 };
 export declare function isWorkflowDeclaration(value: unknown): value is NornAnyWorkflowDeclaration;
 export declare function isWorkflowPlugin(value: unknown): value is NornWorkflowPlugin;

package/dist/api.js

@@ -1,5 +1,15 @@
 // src/api.ts
-import { z } from "zod";
+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 };
+}
+
+// src/api.ts
+import { Value } from "typebox/value";
+import { isPlainObject, jsonValueSchema } from "./schema.js";
 var WORKFLOW_DECLARATION_KIND = "norn.workflow";
 function definePluginManifest(input) {
   assertLocalDeclarationId(input.id, "plugin");
@@ -17,26 +27,26 @@ function definePluginManifest(input) {
 function definePlugin(manifest, implementation) {
   return { manifest, implementation };
 }
-var artifactRefSchema = z.object({
-  path: z.string()
+var artifactRefSchema = Type.Object({
+  path: Type.String()
 });
-var emptyWorkflowRefParamsSchema = z.object({});
+var emptyWorkflowRefParamsSchema = Type.Object({});
+var workflowReferenceInputSchema = Type.Union([
+  Type.String({ minLength: 1 }),
+  Type.Object({ workflow: Type.String({ minLength: 1 }), forwardParams: Type.Record(Type.String(), Type.Unknown()) })
+]);
 function workflowRefSchema(options) {
-  const contributedParams = options?.params ?? emptyWorkflowRefParamsSchema;
-  const targetSchema = z.union([
-    z.string().min(1),
-    z.object({ id: z.string().min(1) })
-  ]).transform((target) => typeof target === "string" ? target : target.id);
-  return z.union([
-    targetSchema,
-    z.object({ workflow: targetSchema, forwardParams: z.record(z.string(), z.unknown()) })
-  ]).transform((reference) => typeof reference === "string" ? { workflow: reference, forwardParams: {} } : reference).meta({
-    "x-norn-workflow-ref": {
-      get contributedParamsSchema() {
-        return z.toJSONSchema(contributedParams, { io: "input" });
-      }
-    }
-  });
+  const contributionSchema = options?.params ?? emptyWorkflowRefParamsSchema;
+  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 } });
+    };
+  }), { "x-norn-workflow-ref": { contributedParamsSchema: contributionSchema } });
 }
 function assertLocalDeclarationId(id, kind) {
   if (id.length === 0) throw new Error(`Workflow ${kind} id must not be empty`);
@@ -56,28 +66,29 @@ function assertPluginQualifiedId(pluginId, id, kind) {
 }
 function qualifyWorkflow(pluginId, key, workflow, declaredIds) {
   const id = resolveDeclarationId(pluginId, [key], workflow.id, "workflow", declaredIds);
-  return { kind: WORKFLOW_DECLARATION_KIND, ...workflow, id, isolation: workflow.isolation ?? { mode: "runWorkspace" } };
+  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) return void 0;
-  if (isZodSchema(node)) return { id: resolveDeclarationId(pluginId, path, void 0, "state", declaredIds), schema: node };
-  if (isWorkflowStateDefinitionInput(node)) {
+  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 isWorkflowDeclaration(value) {
-  if (!value || typeof value !== "object") return false;
+  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 isWorkflowStateDefinitionInput(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return (candidate.id === void 0 || typeof candidate.id === "string") && isZodSchema(candidate.schema);
+function isTypeboxSchema(value) {
+  return Type.IsUnsafe(value) || Boolean(value && typeof value === "object" && "~kind" in value && typeof value["~kind"] === "string");
 }
-function isZodSchema(value) {
-  return Boolean(value && typeof value === "object" && typeof value.safeParse === "function");
+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;

package/dist/files.js

@@ -1,10 +1,7 @@
-// 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 { z } from "zod";
+// ../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) {
@@ -12,9 +9,6 @@ function isNodeError(error) {
 }
 
 // ../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";
 async function writeTextAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
@@ -35,12 +29,19 @@ async function writeTextAtomically(path, content) {
 }
 
 // src/files.ts
-var ownerSchema = z.strictObject({
-  token: z.uuid(),
-  pid: z.number().int().positive(),
-  host: z.string(),
-  target: z.string()
-});
+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;
@@ -127,7 +128,7 @@ var NornFileCoordinator = class {
       if (entries.length === 0) return;
       if (entries.length !== 1) throw new Error(`Invalid file lock ownership: ${input.lockPath}`);
       const marker = entries[0];
-      const owner = ownerSchema.parse(JSON.parse(await readFile(join(input.lockPath, marker), "utf8")));
+      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}`);
       }

package/dist/index.d.ts

@@ -3,4 +3,3 @@ export { NornFileCoordinator } from "./files.ts";
 export * from "./resources.ts";
 export * from "./agent-resource-adapter.ts";
 export * from "./state-adapter.ts";
-export * from "./seer/index.ts";

package/dist/index.js

@@ -4,7 +4,6 @@ import { NornFileCoordinator } from "./files.js";
 export * from "./resources.js";
 export * from "./agent-resource-adapter.js";
 export * from "./state-adapter.js";
-export * from "./seer/index.js";
 export {
   NornFileCoordinator
 };

package/dist/resources.d.ts

@@ -1,5 +1,5 @@
-import type { z } from "zod";
 import type { NornFileCoordinator } from "./files.ts";
+import type { NornJsonValue } from "./schema.ts";
 export type NornResourceContext = {
     readonly mode: "create" | "open";
     readonly directory: string;
@@ -8,7 +8,7 @@ export type NornResourceContext = {
 export type NornResourceDefinition<T> = {
     readonly name: string;
     readonly kind: string;
-    readonly configuration: z.infer<ReturnType<typeof z.json>>;
+    readonly configuration: NornJsonValue;
     initialize(context: NornResourceContext): Promise<T>;
 };
 export type NornResources = {

package/dist/schema.d.ts

@@ -1,6 +1,12 @@
-import type { NornAnyWorkflowDeclaration } from "./api.ts";
+import { Type, type Static, type TSchema } from "typebox";
+import type { NornAnyWorkflowDeclaration, NornJsonSchema } from "./api.ts";
+export declare const jsonValueSchema: Type.TCyclic<{
+    Json: Type.TUnion<[Type.TNull, Type.TBoolean, Type.TNumber, Type.TString, Type.TArray<Type.TRef<"Json">>, Type.TRefine<Type.TRecord<"^.*$", Type.TRef<"Json">>>]>;
+}, "Json">;
+export type NornJsonValue = Static<typeof jsonValueSchema>;
+export declare function inspectSchema(schema: TSchema): NornJsonSchema;
 export declare function assertWorkflowMetadata(workflow: NornAnyWorkflowDeclaration): void;
-export declare function unwrapSchema(schema: unknown): unknown;
-export declare function schemaShape(schema: unknown): Record<string, unknown>;
-export declare function schemaType(schema: unknown): string | undefined;
+export declare function unwrapSchema(schema: TSchema): TSchema;
+export declare function schemaShape(schema: TSchema): Record<string, TSchema>;
+export declare function schemaType(schema: TSchema): string | undefined;
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/schema.js

@@ -1,4 +1,44 @@
 // src/schema.ts
+import { Type } from "typebox";
+import { Meta } from "typebox/schema";
+import { Value } from "typebox/value";
+var jsonValueSchema = Type.Cyclic({
+  Json: Type.Union([
+    Type.Null(),
+    Type.Boolean(),
+    Type.Number(),
+    Type.String(),
+    Type.Array(Type.Ref("Json")),
+    Type.Refine(Type.Record(Type.String(), Type.Ref("Json")), (value) => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)
+  ])
+}, "Json");
+function inspectSchema(schema) {
+  const inspected = JSON.parse(JSON.stringify(schema));
+  Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], inspected);
+  if (!isPlainObject(inspected)) throw new Error("Norn inspection requires an object schema");
+  assertWorkflowReferenceAnnotations(inspected);
+  return inspected;
+}
+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);
+  }
+  for (const keyword of ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]) {
+    const schemas = schema[keyword];
+    if (isPlainObject(schemas)) for (const child of Object.values(schemas)) assertWorkflowReferenceAnnotations(child);
+  }
+  for (const keyword of ["allOf", "anyOf", "oneOf", "prefixItems"]) {
+    const schemas = schema[keyword];
+    if (Array.isArray(schemas)) for (const child of schemas) assertWorkflowReferenceAnnotations(child);
+  }
+  for (const keyword of ["additionalProperties", "unevaluatedProperties", "propertyNames", "items", "contains", "not", "if", "then", "else", "unevaluatedItems", "contentSchema"]) {
+    assertWorkflowReferenceAnnotations(schema[keyword]);
+  }
+}
 function assertWorkflowMetadata(workflow) {
   if (workflow.instructions !== void 0 && (typeof workflow.instructions !== "string" || workflow.instructions.trim().length === 0)) {
     throw new Error(`Workflow instructions must be a nonempty string: ${workflow.id}`);
@@ -8,35 +48,26 @@ function assertWorkflowMetadata(workflow) {
   }
 }
 function unwrapSchema(schema) {
-  let current = schema;
-  while (true) {
-    const def = schemaDef(current);
-    if (["optional", "nullable", "default", "catch", "readonly", "prefault"].includes(def.type ?? "") && def.innerType) {
-      current = def.innerType;
-      continue;
-    }
-    return current;
-  }
+  if (!Type.IsUnion(schema)) return schema;
+  const members = schema.anyOf.filter((member) => !Type.IsNull(member));
+  return members.length === 1 ? unwrapSchema(members[0]) : schema;
 }
 function schemaShape(schema) {
-  const shape = schemaDef(unwrapSchema(schema)).shape;
-  if (!shape) return {};
-  return typeof shape === "function" ? shape() : shape;
+  const unwrapped = unwrapSchema(schema);
+  return Type.IsObject(unwrapped) ? unwrapped.properties : {};
 }
 function schemaType(schema) {
-  return schemaDef(unwrapSchema(schema)).type;
+  const unwrapped = unwrapSchema(schema);
+  return "type" in unwrapped && typeof unwrapped.type === "string" ? unwrapped.type : void 0;
 }
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function schemaDef(schema) {
-  if (!schema || typeof schema !== "object") return {};
-  const candidate = schema;
-  return candidate._def ?? candidate.def ?? {};
-}
 export {
   assertWorkflowMetadata,
+  inspectSchema,
   isPlainObject,
+  jsonValueSchema,
   schemaShape,
   schemaType,
   unwrapSchema

package/dist/state-adapter.d.ts

@@ -1,5 +1,5 @@
-import type { NornWorkflowState, NornWorkflowStateDefinition } from "./api.ts";
 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";

package/dist/state-adapter.js

@@ -1,8 +1,8 @@
 // src/state-adapter.ts
-import { createHash } from "node:crypto";
 import { defineTool } from "@earendil-works/pi-coding-agent";
+import { createHash } from "node:crypto";
 import { Type } from "typebox";
-import { z } from "zod";
+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 })
@@ -26,7 +26,7 @@ function StateAdapter(input) {
             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: z.toJSONSchema(field.schema, { io: "input" }) })), ...params });
+              return serializePage({ value: [...fields.values()].map(({ field, access }) => ({ id: field.id, access, schema: inspectSchema(field.schema) })), ...params });
             }
           }),
           defineTool({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn",
-  "version": "0.1.0-tip.35240723931.1",
+  "version": "0.1.0-tip.35343816255.1",
   "description": "TypeScript SDK for building agent-driven and code-driven Norn workflows.",
   "type": "module",
   "license": "MIT",
@@ -33,10 +33,6 @@
     "./schema": {
       "types": "./dist/schema.d.ts",
       "import": "./dist/schema.js"
-    },
-    "./seer": {
-      "types": "./dist/seer/index.d.ts",
-      "import": "./dist/seer/index.js"
     }
   },
   "devDependencies": {
@@ -44,8 +40,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.85.1",
-    "typebox": "^1.3.17",
-    "zod": "^4.4.3"
+    "typebox": "^1.3.33"
   },
   "scripts": {
     "build": "node ../../scripts/build-package.ts"

package/dist/seer/config.d.ts

@@ -1,17 +0,0 @@
-export type NornSeerModeConfig = {
-    readonly writableRoots: readonly string[];
-};
-export type NornResolvedSeerModeConfig = {
-    readonly configPath: string;
-    readonly projectRoot: string;
-    readonly writableRoots: readonly string[];
-};
-type ResolveSeerModeConfigInput = {
-    readonly configPath: string;
-    readonly configRoot: string;
-    readonly seerMode: NornSeerModeConfig | undefined;
-};
-export declare function resolveSeerModeConfig(input: ResolveSeerModeConfigInput): NornResolvedSeerModeConfig | undefined;
-export declare function assertSeerModeWritablePath(seerMode: NornResolvedSeerModeConfig, cwd: string, path: string): string;
-export declare function isSeerModeWritablePath(seerMode: NornResolvedSeerModeConfig, cwd: string, path: string): boolean;
-export {};

package/dist/seer/config.js

@@ -1,45 +0,0 @@
-// src/seer/config.ts
-import { isAbsolute, relative, resolve, sep } from "node:path";
-function resolveSeerModeConfig(input) {
-  if (!input.seerMode) return void 0;
-  if (input.seerMode.writableRoots.length === 0) throw new Error("Norn seerMode.writableRoots must not be empty");
-  const projectRoot = resolve(input.configRoot);
-  const writableRoots = Array.from(new Set(input.seerMode.writableRoots.map((path) => resolveWritableRoot(projectRoot, path))));
-  return { configPath: input.configPath, projectRoot, writableRoots };
-}
-function assertSeerModeWritablePath(seerMode, cwd, path) {
-  const resolvedPath = resolveSeerModePath(seerMode, cwd, path);
-  if (!isSeerModeWritableResolvedPath(seerMode, resolvedPath)) {
-    throw new Error(`Path is outside Norn seerMode writable roots: ${path}`);
-  }
-  return resolvedPath;
-}
-function isSeerModeWritablePath(seerMode, cwd, path) {
-  return isSeerModeWritableResolvedPath(seerMode, resolveSeerModePath(seerMode, cwd, path));
-}
-function resolveWritableRoot(projectRoot, path) {
-  if (path.length === 0) throw new Error("Norn seerMode writable root must not be empty");
-  const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(projectRoot, path);
-  if (!isInsideOrEqual(projectRoot, resolvedPath)) throw new Error(`Norn seerMode writable root escapes project root: ${path}`);
-  return resolvedPath;
-}
-function resolveSeerModePath(seerMode, cwd, path) {
-  if (path.length === 0) throw new Error("Norn seerMode path must not be empty");
-  const resolvedCwd = resolve(cwd);
-  if (!isInsideOrEqual(seerMode.projectRoot, resolvedCwd)) throw new Error(`Norn seerMode cwd escapes project root: ${cwd}`);
-  const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedCwd, path);
-  if (!isInsideOrEqual(seerMode.projectRoot, resolvedPath)) return resolvedPath;
-  return resolvedPath;
-}
-function isSeerModeWritableResolvedPath(seerMode, path) {
-  return seerMode.writableRoots.some((root) => isInsideOrEqual(root, path));
-}
-function isInsideOrEqual(root, path) {
-  const pathFromRoot = relative(root, path);
-  return pathFromRoot === "" || !pathFromRoot.startsWith(`..${sep}`) && pathFromRoot !== ".." && !isAbsolute(pathFromRoot);
-}
-export {
-  assertSeerModeWritablePath,
-  isSeerModeWritablePath,
-  resolveSeerModeConfig
-};

package/dist/seer/index.d.ts

@@ -1 +0,0 @@
-export { assertSeerModeWritablePath, isSeerModeWritablePath, resolveSeerModeConfig, type NornResolvedSeerModeConfig, type NornSeerModeConfig, } from "./config.ts";

package/dist/seer/index.js

@@ -1,11 +0,0 @@
-// src/seer/index.ts
-import {
-  assertSeerModeWritablePath,
-  isSeerModeWritablePath,
-  resolveSeerModeConfig
-} from "./config.js";
-export {
-  assertSeerModeWritablePath,
-  isSeerModeWritablePath,
-  resolveSeerModeConfig
-};