@vimhead.dev/norn 0.1.0-tip.35614826665.1 → 0.1.0-tip.35724621678.1

package/dist/api.js

@@ -1,21 +1,32 @@
 // src/api.ts
-import { Type } from "typebox";
+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");
+  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, args: input.args };
 }
 
 // src/api.ts
 import { Value } from "typebox/value";
-import { assertWorkflowMetadata, isPlainObject, jsonValueSchema } from "./schema.js";
+import {
+  assertWorkflowMetadata,
+  isPlainObject,
+  jsonValueSchema
+} from "./schema.js";
 var WORKFLOW_DECLARATION_KIND = "norn.workflow";
 function workflow(definition) {
   return createWorkflow({ definition, id: definition.name, scope: void 0 });
 }
 function createWorkflow(input) {
-  const { definition: { name, ...properties }, id, scope } = input;
+  const {
+    definition: { name, ...properties },
+    id,
+    scope
+  } = input;
   assertDeclarationName(name);
   const callable = (args) => createWorkflowTransition({ workflowId: id, args });
   const result = Object.assign(callable, properties, {
@@ -24,7 +35,8 @@ function createWorkflow(input) {
     scope
   });
   assertWorkflowMetadata(result);
-  if (!isWorkflowDeclaration(result)) throw new Error(`Invalid workflow definition: ${id}`);
+  if (!isWorkflowDeclaration(result))
+    throw new Error(`Invalid workflow definition: ${id}`);
   return result;
 }
 function workflowScope(input) {
@@ -34,30 +46,47 @@ function workflowScope(input) {
     id: scope.id,
     config: scope.config,
     workflow(definition) {
-      return createWorkflow({ definition, id: `${scope.id}.${definition.name}`, scope });
+      return createWorkflow({
+        definition,
+        id: `${scope.id}.${definition.name}`,
+        scope
+      });
     }
   };
 }
 var emptyWorkflowRefArgsSchema = Type.Object({});
 var workflowReferenceInputSchema = Type.Union([
   Type.String({ minLength: 1 }),
-  Type.Object({ workflow: Type.String({ minLength: 1 }), forwardArgs: 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?.args ?? emptyWorkflowRefArgsSchema;
-  return Type.With(Type.Decode(workflowReferenceInputSchema, (reference) => {
-    const workflowId = typeof reference === "string" ? reference : reference.workflow;
-    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": { contributedArgsSchema: contributionSchema } });
+  return Type.With(
+    Type.Decode(workflowReferenceInputSchema, (reference) => {
+      const workflowId = typeof reference === "string" ? reference : reference.workflow;
+      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": { contributedArgsSchema: contributionSchema } }
+  );
 }
 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`);
+  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;

package/dist/index.d.ts

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

package/dist/schema.js

@@ -2,20 +2,27 @@
 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");
+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");
+  if (!isPlainObject(inspected))
+    throw new Error("Norn inspection requires an object schema");
   assertWorkflowReferenceAnnotations(inspected);
   return inspected;
 }
@@ -23,28 +30,58 @@ 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, "contributedArgsSchema")) throw new Error("Invalid workflow reference annotation");
-    Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], annotation.contributedArgsSchema);
+    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"]) {
+  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);
+    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);
+    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"]) {
+  for (const keyword of [
+    "additionalProperties",
+    "unevaluatedProperties",
+    "propertyNames",
+    "items",
+    "contains",
+    "not",
+    "if",
+    "then",
+    "else",
+    "unevaluatedItems",
+    "contentSchema"
+  ]) {
     assertWorkflowReferenceAnnotations(schema[keyword]);
   }
 }
 function assertWorkflowMetadata(workflow) {
   const { entrypoint } = workflow;
   if (entrypoint === false) return;
-  if (!isPlainObject(entrypoint)) throw new Error(`Workflow entrypoint must be false or an object with instructions: ${workflow.id}`);
+  if (!isPlainObject(entrypoint))
+    throw new Error(
+      `Workflow entrypoint must be false or an object with instructions: ${workflow.id}`
+    );
   if (typeof entrypoint.instructions !== "string" || entrypoint.instructions.trim().length === 0) {
-    throw new Error(`Workflow entrypoint.instructions must be a nonempty string: ${workflow.id}`);
+    throw new Error(
+      `Workflow entrypoint.instructions must be a nonempty string: ${workflow.id}`
+    );
   }
 }
 function unwrapSchema(schema) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn",
-  "version": "0.1.0-tip.35614826665.1",
+  "version": "0.1.0-tip.35724621678.1",
   "description": "TypeScript SDK for building agent-driven and code-driven Norn workflows.",
   "type": "module",
   "license": "MIT",