@sixb/core 0.0.1

package/dist/chunk-0psb6kdw.js

@@ -0,0 +1,989 @@
+// @bun
+import {
+  isScheduleDefinition
+} from "./chunk-867jxh7c.js";
+import {
+  isActionDefinition
+} from "./chunk-jdwx7vzs.js";
+import {
+  isObjectRefSchema,
+  validateSchemaOrRefValue
+} from "./chunk-45tw90k7.js";
+import {
+  reportRunFailure
+} from "./chunk-t72dvahb.js";
+import {
+  isAgentDefinition
+} from "./chunk-nvamz5dv.js";
+import {
+  SYSTEM_PRINCIPAL
+} from "./chunk-dcgrzj1t.js";
+import {
+  assertAuthorized
+} from "./chunk-0fygrz37.js";
+
+// src/workflows/errors.ts
+class WorkflowDefinitionError extends Error {
+  name = "WorkflowDefinitionError";
+}
+
+class WorkflowValidationError extends Error {
+  name = "WorkflowValidationError";
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.cause = options?.cause;
+  }
+}
+
+// src/workflows/validation.ts
+function assertNonEmpty(value, subject, field) {
+  if (!value.trim()) {
+    throw new WorkflowDefinitionError(`${subject} ${field} must not be empty.`);
+  }
+}
+function isStepDefinition(value) {
+  return isRecord(value) && value.kind === "step" && typeof value.id === "string" && isRecord(value.input) && isRecord(value.output) && typeof value.handler === "function";
+}
+function isAgentStepDefinition(value) {
+  return isRecord(value) && value.kind === "agentStep" && typeof value.id === "string" && isAgentDefinition(value.agent) && isRecord(value.input) && isRecord(value.output) && typeof value.prompt === "function";
+}
+function isInterventionDefinition(value) {
+  return isRecord(value) && value.kind === "intervention" && typeof value.id === "string" && isRecord(value.input) && isRecord(value.response) && (value.defaults === undefined || typeof value.defaults === "function");
+}
+function isWorkflowDefinition(value) {
+  return isRecord(value) && value.kind === "workflow" && typeof value.id === "string" && isRecord(value.input) && Array.isArray(value.triggers) && Array.isArray(value.nodes);
+}
+function validateWorkflowDefinition(value) {
+  if (!isWorkflowDefinition(value)) {
+    throw new WorkflowDefinitionError("Invalid workflow definition.");
+  }
+  assertNonEmpty(value.id, "Workflow", "id");
+  if (value.nodes.length === 0) {
+    throw new WorkflowDefinitionError(`Workflow "${value.id}" must contain at least one node.`);
+  }
+  const nodeIds = new Set;
+  const nodeKeys = new Set;
+  for (const node of value.nodes) {
+    validateWorkflowNodeDefinition(value.id, node);
+    if (nodeIds.has(node.id)) {
+      throw new WorkflowDefinitionError(`Duplicate workflow node id "${node.id}" in workflow "${value.id}".`);
+    }
+    nodeIds.add(node.id);
+    if (nodeKeys.has(node.key)) {
+      throw new WorkflowDefinitionError(`Duplicate workflow node key "${node.key}" in workflow "${value.id}".`);
+    }
+    nodeKeys.add(node.key);
+  }
+}
+function validateWorkflowsAtStartup(options) {
+  for (const workflow of options.workflows) {
+    validateWorkflowDefinition(workflow);
+    for (const trigger of workflow.triggers) {
+      validateWorkflowTriggerAtStartup(workflow.id, trigger, options.registeredSchedules, Object.keys(workflow.input));
+    }
+    for (const node of workflow.nodes) {
+      if (node.type === "action" && !options.registeredActionIds.has(node.action.id)) {
+        throw new WorkflowDefinitionError(`Workflow "${workflow.id}" references unknown action "${node.action.id}". Add it to 'actions' in createSixb() or export it from 'actions/'.`);
+      }
+      if (node.type === "agent" && !options.registeredAgentIds.has(node.agentStep.agent.id)) {
+        throw new WorkflowDefinitionError(`Workflow "${workflow.id}" references unknown agent "${node.agentStep.agent.id}". Add it to 'agents' in createSixb() or export it from 'agents/'.`);
+      }
+    }
+  }
+  return options.workflows;
+}
+function validateWorkflowInput(params) {
+  return validateWorkflowContractRecord({
+    shape: params.workflow.input,
+    value: params.value,
+    path: `Workflow "${params.workflow.id}" input`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function validateWorkflowStepInput(params) {
+  return validateWorkflowContractRecord({
+    shape: params.step.input,
+    value: params.value,
+    path: `Workflow "${params.workflowId}" step "${params.step.id}" input`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function validateWorkflowStepOutput(params) {
+  return validateWorkflowContractRecord({
+    shape: params.step.output,
+    value: params.value,
+    path: `Workflow "${params.workflowId}" step "${params.step.id}" output`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function validateWorkflowInterventionInput(params) {
+  return validateWorkflowContractRecord({
+    shape: params.intervention.input,
+    value: params.value,
+    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" input`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function validateWorkflowInterventionResponse(params) {
+  return validateWorkflowInterventionResponseRecord({
+    response: params.intervention.response,
+    value: params.value,
+    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" response`,
+    partial: false,
+    valueTypesById: params.valueTypesById
+  });
+}
+function validateWorkflowInterventionDefaultResponse(params) {
+  return validateWorkflowInterventionResponseRecord({
+    response: params.intervention.response,
+    value: params.value,
+    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" defaultResponse`,
+    partial: true,
+    valueTypesById: params.valueTypesById
+  });
+}
+function validateWorkflowTriggerAtStartup(workflowId, trigger, registeredSchedules, inputFields) {
+  if (!isRecord(trigger) || trigger.type !== "schedule") {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an unsupported trigger.`);
+  }
+  validateScheduleWorkflowTrigger(workflowId, trigger, registeredSchedules, inputFields);
+}
+function validateScheduleWorkflowTrigger(workflowId, trigger, registeredSchedules, inputFields) {
+  if (typeof trigger.scheduleId !== "string" || !trigger.scheduleId.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains a schedule trigger with an empty schedule id.`);
+  }
+  const schedule = registeredSchedules.get(trigger.scheduleId);
+  if (!schedule) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" references unknown schedule "${trigger.scheduleId}". Add it to 'schedules' in createSixb() or export it from 'schedules/'.`);
+  }
+  if (trigger.mapper !== undefined && typeof trigger.mapper !== "function") {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" schedule "${trigger.scheduleId}" mapper must be a function.`);
+  }
+  if (trigger.mapper !== undefined && schedule.trigger.type !== "event") {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" cron schedule "${trigger.scheduleId}" does not accept a mapper.`);
+  }
+  if (trigger.mapper === undefined && inputFields.length > 0) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" schedule "${trigger.scheduleId}" requires a mapper because workflow input is not empty: ${inputFields.join(", ")}.`);
+  }
+}
+function validateWorkflowNodeDefinition(workflowId, node) {
+  if (!isRecord(node)) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid node.`);
+  }
+  if (node.type === "step") {
+    validateStepNodeDefinition(workflowId, node);
+    return;
+  }
+  if (node.type === "agent") {
+    validateAgentNodeDefinition(workflowId, node);
+    return;
+  }
+  if (node.type === "intervention") {
+    validateInterventionNodeDefinition(workflowId, node);
+    return;
+  }
+  if (node.type === "action") {
+    validateActionNodeDefinition(workflowId, node);
+    return;
+  }
+  throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an unsupported node type.`);
+}
+function validateAgentNodeDefinition(workflowId, node) {
+  if (typeof node.id !== "string" || !node.id.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an agent step with an empty id.`);
+  }
+  if (typeof node.key !== "string" || !node.key.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains agent step "${node.id}" with an empty derived key.`);
+  }
+  if (!isAgentStepDefinition(node.agentStep)) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid agent node "${node.id}".`);
+  }
+  if (node.id !== node.agentStep.id) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent node id "${node.id}" does not match agent step definition id "${node.agentStep.id}".`);
+  }
+  if (node.mapper !== undefined && typeof node.mapper !== "function") {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent node "${node.id}" mapper must be a function.`);
+  }
+}
+function validateWorkflowAgentStepInput(params) {
+  return validateWorkflowContractRecord({
+    shape: params.agentStep.input,
+    value: params.value,
+    path: `Workflow "${params.workflowId}" agent step "${params.agentStep.id}" input`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function validateWorkflowAgentStepOutput(params) {
+  return validateWorkflowContractRecord({
+    shape: params.agentStep.output,
+    value: params.value,
+    path: `Workflow "${params.workflowId}" agent step "${params.agentStep.id}" output`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function validateStepNodeDefinition(workflowId, node) {
+  if (typeof node.id !== "string" || !node.id.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains a step with an empty id.`);
+  }
+  if (typeof node.key !== "string" || !node.key.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains step "${node.id}" with an empty derived key.`);
+  }
+  if (!isStepDefinition(node.step)) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid step node "${node.id}".`);
+  }
+  if (node.id !== node.step.id) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" step node id "${node.id}" does not match step definition id "${node.step.id}".`);
+  }
+  if (node.mapper !== undefined && typeof node.mapper !== "function") {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" step node "${node.id}" mapper must be a function.`);
+  }
+}
+function validateInterventionNodeDefinition(workflowId, node) {
+  if (typeof node.id !== "string" || !node.id.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an intervention with an empty id.`);
+  }
+  if (typeof node.key !== "string" || !node.key.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains intervention "${node.id}" with an empty derived key.`);
+  }
+  if (!isInterventionDefinition(node.intervention)) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid intervention node "${node.id}".`);
+  }
+  if (node.id !== node.intervention.id) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" intervention node id "${node.id}" does not match intervention definition id "${node.intervention.id}".`);
+  }
+  if (node.mapper !== undefined && typeof node.mapper !== "function") {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" intervention node "${node.id}" mapper must be a function.`);
+  }
+}
+function validateActionNodeDefinition(workflowId, node) {
+  if (typeof node.id !== "string" || !node.id.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an action with an empty id.`);
+  }
+  if (typeof node.key !== "string" || !node.key.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains action "${node.id}" with an empty derived key.`);
+  }
+  if (!isActionDefinition(node.action)) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid action node "${node.id}".`);
+  }
+  if (node.id !== node.action.id) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" action node id "${node.id}" does not match action definition id "${node.action.id}".`);
+  }
+  if (node.mapper !== undefined && typeof node.mapper !== "function") {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" action node "${node.id}" mapper must be a function.`);
+  }
+}
+function validateWorkflowContractRecord(params) {
+  if (!isRecord(params.value)) {
+    throw new WorkflowValidationError(`[Sixb] ${params.path} must be an object`);
+  }
+  const fieldIds = new Set(Object.keys(params.shape));
+  for (const fieldId of Object.keys(params.value)) {
+    if (!fieldIds.has(fieldId)) {
+      throw new WorkflowValidationError(`[Sixb] Unknown field '${params.path}.${fieldId}'`);
+    }
+  }
+  for (const [fieldId, schema] of Object.entries(params.shape)) {
+    const fieldValue = params.value[fieldId];
+    if (fieldValue === undefined) {
+      throw new WorkflowValidationError(`[Sixb] Missing required field '${params.path}.${fieldId}'`);
+    }
+    try {
+      validateSchemaOrRefValue(schema, fieldValue, `${params.path}.${fieldId}`, params.valueTypesById);
+    } catch (error) {
+      throw toWorkflowValidationError(error);
+    }
+  }
+  return params.value;
+}
+function validateWorkflowInterventionResponseRecord(params) {
+  if (!isRecord(params.value)) {
+    throw new WorkflowValidationError(`[Sixb] ${params.path} must be an object`);
+  }
+  const fieldIds = new Set(Object.keys(params.response));
+  for (const fieldId of Object.keys(params.value)) {
+    if (!fieldIds.has(fieldId)) {
+      throw new WorkflowValidationError(`[Sixb] Unknown field '${params.path}.${fieldId}'`);
+    }
+  }
+  for (const [fieldId, field] of Object.entries(params.response)) {
+    const fieldValue = params.value[fieldId];
+    if (fieldValue === undefined) {
+      if (!params.partial && isInterventionResponseFieldRequired(field)) {
+        throw new WorkflowValidationError(`[Sixb] Missing required field '${params.path}.${fieldId}'`);
+      }
+      continue;
+    }
+    try {
+      validateSchemaOrRefValue(interventionResponseFieldSchema(field), fieldValue, `${params.path}.${fieldId}`, params.valueTypesById);
+    } catch (error) {
+      throw toWorkflowValidationError(error);
+    }
+  }
+  return params.value;
+}
+function isInterventionFieldConfig(value) {
+  return isRecord(value) && "schema" in value;
+}
+function interventionResponseFieldSchema(field) {
+  return isInterventionFieldConfig(field) ? field.schema : field;
+}
+function isInterventionResponseFieldRequired(field) {
+  return !isInterventionFieldConfig(field) || field.required !== false;
+}
+function toWorkflowValidationError(error) {
+  if (error instanceof WorkflowValidationError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new WorkflowValidationError(error.message, { cause: error });
+  }
+  return new WorkflowValidationError(String(error), { cause: error });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/workflows/builders.ts
+function interventionField(schema, options) {
+  return {
+    schema,
+    required: options?.required ?? true,
+    ...options?.description !== undefined ? { description: options.description } : {}
+  };
+}
+function defineWorkflowStep(id) {
+  assertNonEmpty(id, "Step", "id");
+  return {
+    input(input) {
+      return {
+        output(output) {
+          return {
+            run(handler) {
+              return {
+                kind: "step",
+                id,
+                input,
+                output,
+                handler
+              };
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function defineAgentStep(id, agent) {
+  assertNonEmpty(id, "Agent step", "id");
+  if (!isAgentDefinition(agent)) {
+    throw new WorkflowDefinitionError(`Agent step "${id}" references an invalid agent.`);
+  }
+  return {
+    input(input) {
+      return {
+        output(output) {
+          return {
+            prompt(prompt) {
+              if (typeof prompt !== "function") {
+                throw new WorkflowDefinitionError(`Agent step "${id}" prompt must be a function.`);
+              }
+              return { kind: "agentStep", id, agent, input, output, prompt };
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function defineIntervention(id, options) {
+  assertNonEmpty(id, "Intervention", "id");
+  return {
+    input(input) {
+      return {
+        response(response) {
+          return createInterventionDefinition({
+            id,
+            input,
+            response,
+            description: options?.description
+          });
+        }
+      };
+    }
+  };
+}
+function defineWorkflow(id) {
+  assertNonEmpty(id, "Workflow", "id");
+  return {
+    input(input) {
+      return createWorkflowDraftBuilder(id, input);
+    }
+  };
+}
+function createWorkflowDraftBuilder(id, input) {
+  const triggers = [];
+  const nodes = [];
+  let definition = null;
+  const appendNode = (nodeDefinition, mapper, ...extraArgs) => {
+    if (extraArgs.length > 0) {
+      throw new WorkflowDefinitionError(`Invalid workflow "${id}" .then(...) call.`);
+    }
+    if (isStepDefinition(nodeDefinition)) {
+      if (mapper !== undefined && !isRuntimeWorkflowMapper(mapper)) {
+        throw new WorkflowDefinitionError(`Invalid workflow "${id}" .then(...) call.`);
+      }
+      nodes.push(createStepNode(id, nodes, nodeDefinition, mapper));
+      definition ??= createWorkflowDefinition(id, input, triggers, nodes, appendNode);
+      return definition;
+    }
+    if (isAgentStepDefinition(nodeDefinition)) {
+      if (mapper !== undefined && !isRuntimeWorkflowMapper(mapper)) {
+        throw new WorkflowDefinitionError(`Invalid workflow "${id}" .then(...) call.`);
+      }
+      nodes.push(createAgentNode(id, nodes, nodeDefinition, mapper));
+      definition ??= createWorkflowDefinition(id, input, triggers, nodes, appendNode);
+      return definition;
+    }
+    if (isInterventionDefinition(nodeDefinition)) {
+      if (mapper !== undefined && !isRuntimeWorkflowMapper(mapper)) {
+        throw new WorkflowDefinitionError(`Invalid workflow "${id}" .then(...) call.`);
+      }
+      nodes.push(createInterventionNode(id, nodes, nodeDefinition, mapper));
+      definition ??= createWorkflowDefinition(id, input, triggers, nodes, appendNode);
+      return definition;
+    }
+    if (isActionDefinition(nodeDefinition)) {
+      if (mapper !== undefined && !isRuntimeWorkflowMapper(mapper)) {
+        throw new WorkflowDefinitionError(`Invalid workflow "${id}" .then(...) call.`);
+      }
+      nodes.push(createActionNode(id, nodes, nodeDefinition, mapper));
+      definition ??= createWorkflowDefinition(id, input, triggers, nodes, appendNode);
+      return definition;
+    }
+    throw new WorkflowDefinitionError(`Invalid workflow "${id}" .then(...) call.`);
+  };
+  let draft;
+  function when(schedule, mapper, ...extraArgs) {
+    if (extraArgs.length > 0) {
+      throw new WorkflowDefinitionError(`Invalid workflow "${id}" .when(...) call.`);
+    }
+    if (isScheduleDefinition(schedule)) {
+      if (mapper !== undefined && schedule.trigger.type !== "event") {
+        throw new WorkflowDefinitionError(`Workflow "${id}" cron schedules do not accept a mapper.`);
+      }
+      if (mapper !== undefined && !isRuntimeWorkflowScheduleMapper(mapper)) {
+        throw new WorkflowDefinitionError(`Invalid workflow "${id}" .when(...) schedule mapper.`);
+      }
+      triggers.push({
+        type: "schedule",
+        scheduleId: schedule.id,
+        ...mapper !== undefined ? { mapper } : {}
+      });
+      return draft;
+    }
+    throw new WorkflowDefinitionError(`Workflow "${id}" .when(...) only accepts schedules.`);
+  }
+  draft = {
+    when,
+    then: appendNode
+  };
+  return draft;
+}
+function createWorkflowDefinition(id, input, triggers, nodes, then) {
+  return {
+    kind: "workflow",
+    id,
+    input,
+    triggers,
+    nodes,
+    then
+  };
+}
+function createStepNode(workflowId, nodes, step, mapper) {
+  const key = deriveWorkflowNodeKey(step.id);
+  assertNodeKey(workflowId, step.id, key);
+  assertUniqueNode(workflowId, nodes, step.id, key);
+  return {
+    type: "step",
+    id: step.id,
+    key,
+    step,
+    ...mapper !== undefined ? { mapper } : {}
+  };
+}
+function createAgentNode(workflowId, nodes, agentStep, mapper) {
+  const key = deriveWorkflowNodeKey(agentStep.id);
+  assertNodeKey(workflowId, agentStep.id, key);
+  assertUniqueNode(workflowId, nodes, agentStep.id, key);
+  return {
+    type: "agent",
+    id: agentStep.id,
+    key,
+    agentStep,
+    ...mapper !== undefined ? { mapper } : {}
+  };
+}
+function createInterventionDefinition(input) {
+  const base = {
+    kind: "intervention",
+    id: input.id,
+    input: input.input,
+    response: input.response,
+    ...input.description !== undefined ? { description: input.description } : {}
+  };
+  const defaults = (handlerOrContext) => {
+    if (typeof handlerOrContext === "function") {
+      return {
+        ...base,
+        defaults: handlerOrContext
+      };
+    }
+    return {};
+  };
+  Object.defineProperty(base, "defaults", {
+    value: defaults,
+    enumerable: false
+  });
+  return base;
+}
+function createActionNode(workflowId, nodes, action, mapper) {
+  const key = deriveWorkflowNodeKey(action.id);
+  assertNodeKey(workflowId, action.id, key);
+  assertUniqueNode(workflowId, nodes, action.id, key);
+  return {
+    type: "action",
+    id: action.id,
+    key,
+    action,
+    ...mapper !== undefined ? { mapper } : {}
+  };
+}
+function createInterventionNode(workflowId, nodes, intervention, mapper) {
+  const key = deriveWorkflowNodeKey(intervention.id);
+  assertNodeKey(workflowId, intervention.id, key);
+  assertUniqueNode(workflowId, nodes, intervention.id, key);
+  return {
+    type: "intervention",
+    id: intervention.id,
+    key,
+    intervention,
+    ...mapper !== undefined ? { mapper } : {}
+  };
+}
+function assertNodeKey(workflowId, nodeId, key) {
+  if (key.length === 0) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" node id "${nodeId}" must contain at least one letter or number.`);
+  }
+}
+function assertUniqueNode(workflowId, nodes, nodeId, key) {
+  const duplicateId = nodes.find((node) => node.id === nodeId);
+  if (duplicateId) {
+    throw new WorkflowDefinitionError(`Duplicate workflow node id "${nodeId}" in workflow "${workflowId}".`);
+  }
+  const duplicateKey = nodes.find((node) => node.key === key);
+  if (duplicateKey) {
+    throw new WorkflowDefinitionError(`Duplicate workflow node key "${key}" in workflow "${workflowId}". Node ids "${duplicateKey.id}" and "${nodeId}" derive the same key.`);
+  }
+}
+function deriveWorkflowNodeKey(id) {
+  const segments = id.trim().split(/[^A-Za-z0-9]+/).filter((segment) => segment.length > 0);
+  return segments.map((segment, index) => {
+    const normalized = uncapitalize(segment);
+    return index === 0 ? normalized : capitalize(normalized);
+  }).join("");
+}
+function uncapitalize(value) {
+  return value.length === 0 ? value : `${value[0].toLowerCase()}${value.slice(1)}`;
+}
+function capitalize(value) {
+  return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+function isRuntimeWorkflowMapper(value) {
+  return typeof value === "function";
+}
+function isRuntimeWorkflowScheduleMapper(value) {
+  return typeof value === "function";
+}
+// src/workflows/request.ts
+import { randomUUID } from "crypto";
+
+// src/workflows/snapshot.ts
+function snapshotWorkflowAgentStepInput(params) {
+  const value = validateWorkflowAgentStepInput(params);
+  return snapshotWorkflowContractRecord({
+    shape: params.agentStep.input,
+    value,
+    path: `Workflow "${params.workflowId}" agent step "${params.agentStep.id}" input`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function snapshotWorkflowAgentStepOutput(params) {
+  const value = validateWorkflowAgentStepOutput(params);
+  return snapshotWorkflowContractRecord({
+    shape: params.agentStep.output,
+    value,
+    path: `Workflow "${params.workflowId}" agent step "${params.agentStep.id}" output`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function snapshotWorkflowInput(params) {
+  const value = validateWorkflowInput(params);
+  return snapshotWorkflowContractRecord({
+    shape: params.workflow.input,
+    value,
+    path: `Workflow "${params.workflow.id}" input`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function snapshotWorkflowStepInput(params) {
+  const value = validateWorkflowStepInput(params);
+  return snapshotWorkflowContractRecord({
+    shape: params.step.input,
+    value,
+    path: `Workflow "${params.workflowId}" step "${params.step.id}" input`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function snapshotWorkflowStepOutput(params) {
+  const value = validateWorkflowStepOutput(params);
+  return snapshotWorkflowContractRecord({
+    shape: params.step.output,
+    value,
+    path: `Workflow "${params.workflowId}" step "${params.step.id}" output`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function snapshotWorkflowInterventionInput(params) {
+  const value = validateWorkflowInterventionInput(params);
+  return snapshotWorkflowContractRecord({
+    shape: params.intervention.input,
+    value,
+    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" input`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function snapshotWorkflowInterventionResponse(params) {
+  const value = validateWorkflowInterventionResponse(params);
+  return snapshotWorkflowInterventionResponseRecord({
+    response: params.intervention.response,
+    value,
+    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" response`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function snapshotWorkflowInterventionDefaultResponse(params) {
+  const value = validateWorkflowInterventionDefaultResponse(params);
+  return snapshotWorkflowInterventionResponseRecord({
+    response: params.intervention.response,
+    value,
+    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" defaultResponse`,
+    valueTypesById: params.valueTypesById
+  });
+}
+function snapshotWorkflowActionInput(params) {
+  const snapshot = {
+    params: snapshotJsonValue(params.params, "Workflow action params")
+  };
+  if (params.subject && params.subject.kind !== "none") {
+    snapshot.subject = snapshotJsonValue(params.subject, "Workflow action subject");
+  }
+  return snapshot;
+}
+function snapshotWorkflowContractRecord(params) {
+  const snapshot = {};
+  for (const [fieldId, schema] of Object.entries(params.shape)) {
+    snapshot[fieldId] = snapshotSchemaOrRefValue({
+      schema,
+      value: params.value[fieldId],
+      path: `${params.path}.${fieldId}`,
+      valueTypesById: params.valueTypesById
+    });
+  }
+  return snapshot;
+}
+function snapshotWorkflowInterventionResponseRecord(params) {
+  const snapshot = {};
+  for (const [fieldId, value] of Object.entries(params.value)) {
+    if (value === undefined) {
+      continue;
+    }
+    snapshot[fieldId] = snapshotSchemaOrRefValue({
+      schema: interventionResponseFieldSchema(params.response[fieldId]),
+      value,
+      path: `${params.path}.${fieldId}`,
+      valueTypesById: params.valueTypesById
+    });
+  }
+  return snapshot;
+}
+function snapshotSchemaOrRefValue(params) {
+  if (isObjectRefSchema(params.schema)) {
+    if (!isRecord2(params.value)) {
+      throw cannotSerialize(params.path);
+    }
+    return {
+      objectTypeId: String(params.value.objectTypeId),
+      primaryId: String(params.value.primaryId)
+    };
+  }
+  return snapshotSchemaValue({
+    schema: params.schema,
+    value: params.value,
+    path: params.path,
+    valueTypesById: params.valueTypesById
+  });
+}
+function snapshotSchemaValue(params) {
+  const { schema, value, path, valueTypesById } = params;
+  if (typeof schema === "string") {
+    if (schema === "date" || schema === "timestamp") {
+      if (value instanceof Date) {
+        return snapshotDate(value, path);
+      }
+      return snapshotJsonValue(value, path);
+    }
+    return snapshotJsonValue(value, path);
+  }
+  if (schema.type === "enum") {
+    return snapshotJsonValue(value, path);
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(value)) {
+      throw cannotSerialize(path);
+    }
+    return value.map((item, index) => snapshotSchemaValue({
+      schema: schema.items,
+      value: item,
+      path: `${path}[${index}]`,
+      valueTypesById
+    }));
+  }
+  if (schema.type === "map") {
+    if (!isRecord2(value)) {
+      throw cannotSerialize(path);
+    }
+    const snapshot = {};
+    for (const [key, entry] of Object.entries(value)) {
+      snapshot[key] = snapshotSchemaValue({
+        schema: schema.valueSchema,
+        value: entry,
+        path: `${path}.${key}`,
+        valueTypesById
+      });
+    }
+    return snapshot;
+  }
+  if (schema.type === "object") {
+    if (!isRecord2(value)) {
+      throw cannotSerialize(path);
+    }
+    const snapshot = {};
+    for (const [fieldId, field] of Object.entries(schema.properties)) {
+      const fieldValue = value[fieldId];
+      if (fieldValue === undefined) {
+        continue;
+      }
+      if (fieldValue === null) {
+        snapshot[fieldId] = null;
+        continue;
+      }
+      snapshot[fieldId] = snapshotSchemaValue({
+        schema: field.schema,
+        value: fieldValue,
+        path: `${path}.${fieldId}`,
+        valueTypesById
+      });
+    }
+    return snapshot;
+  }
+  if (schema.type === "valueTypeRef") {
+    const valueType = valueTypesById.get(schema.valueTypeId);
+    if (!valueType) {
+      throw new WorkflowValidationError(`[Sixb] Unknown valueTypeRef '${schema.valueTypeId}' at ${path}`);
+    }
+    return snapshotSchemaValue({
+      schema: valueType.schema,
+      value,
+      path,
+      valueTypesById
+    });
+  }
+  return snapshotJsonValue(value, path);
+}
+function snapshotJsonValue(value, path) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw cannotSerialize(path);
+    }
+    return value;
+  }
+  if (value instanceof Date) {
+    return snapshotDate(value, path);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => snapshotJsonValue(item, `${path}[${index}]`));
+  }
+  if (isPlainRecord(value)) {
+    const snapshot = {};
+    for (const [key, entry] of Object.entries(value)) {
+      snapshot[key] = snapshotJsonValue(entry, `${path}.${key}`);
+    }
+    return snapshot;
+  }
+  throw cannotSerialize(path);
+}
+function snapshotDate(value, path) {
+  if (Number.isNaN(value.getTime())) {
+    throw cannotSerialize(path);
+  }
+  return value.toISOString();
+}
+function cannotSerialize(path) {
+  return new WorkflowValidationError(`[Sixb] ${path} cannot be serialized as workflow IO`);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// src/workflows/request.ts
+async function requestWorkflowRun(runtime, workflow, options = {}) {
+  assertAuthorized(runtime, { kind: "workflow.run", workflowId: workflow.id });
+  const storage = runtime.storage.workflowRuns;
+  if (!storage) {
+    throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.");
+  }
+  const queue = runtime.queues.workflows;
+  if (!queue) {
+    throw new WorkflowValidationError("[Sixb] Workflow run queue is not configured.");
+  }
+  const runId = createWorkflowRunId(options.runId);
+  const value = options.input ?? {};
+  const snapshot = snapshotWorkflowInput({
+    workflow,
+    value,
+    valueTypesById: runtime.ontology.getValueTypesById()
+  });
+  const existing = await storage.getById({ projectId: runtime.projectId, id: runId });
+  if (existing) {
+    if (existing.workflowId !== workflow.id) {
+      throw new WorkflowValidationError(`[Sixb] Workflow run '${runId}' already exists for a different workflow '${existing.workflowId}'.`);
+    }
+    return {
+      workflowId: workflow.id,
+      runId,
+      queuedAt: (existing.queuedAt ?? existing.startedAt).toISOString(),
+      created: false
+    };
+  }
+  const queuedAt = new Date;
+  await storage.queue({
+    projectId: runtime.projectId,
+    id: runId,
+    workflowId: workflow.id,
+    input: snapshot,
+    queuedAt,
+    source: options.source,
+    requestedByPrincipal: runtime.authorization?.principal ?? (options.source?.type === "schedule" ? options.source.principal : SYSTEM_PRINCIPAL)
+  });
+  let job;
+  try {
+    [job] = await queue.enqueue({
+      projectId: runtime.projectId,
+      jobs: [
+        {
+          type: "workflow.run.requested",
+          payload: { workflowId: workflow.id, runId, input: value }
+        }
+      ]
+    });
+  } catch (error) {
+    const failed = await storage.finish({
+      projectId: runtime.projectId,
+      id: runId,
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error)
+    });
+    reportRunFailure(runtime, error, {
+      projectId: runtime.projectId,
+      occurredAt: failed.finishedAt,
+      run: {
+        kind: "workflow",
+        runId,
+        workflowId: workflow.id
+      }
+    });
+    throw error;
+  }
+  await runtime.events.emit({
+    events: [
+      {
+        type: "workflow.run.queued",
+        payload: {
+          workflowId: workflow.id,
+          runId,
+          queuedAt: queuedAt.toISOString(),
+          ...job?.id ? { jobId: job.id } : {},
+          ...options.source ? { source: options.source } : {}
+        }
+      }
+    ]
+  }, { source: "Sixb" });
+  return {
+    workflowId: workflow.id,
+    runId,
+    queuedAt: queuedAt.toISOString(),
+    jobId: job?.id,
+    created: true
+  };
+}
+function createWorkflowRunId(runId) {
+  if (runId !== undefined) {
+    if (!runId.trim()) {
+      throw new WorkflowValidationError("[Sixb] Workflow run id must not be empty");
+    }
+    return runId;
+  }
+  return `run_${randomUUID()}`;
+}
+// src/workflows/runtime.ts
+class WorkflowsRuntime {
+  runtime;
+  workflowsById;
+  constructor(runtime, workflows) {
+    this.runtime = runtime;
+    this.workflowsById = new Map(workflows.map((workflow) => [workflow.id, workflow]));
+  }
+  list() {
+    return [...this.workflowsById.values()];
+  }
+  getById(workflowId) {
+    return this.workflowsById.get(workflowId) ?? null;
+  }
+  request(workflow, options = {}) {
+    return this.requestById({ workflowId: workflow.id, ...options });
+  }
+  async requestById(input) {
+    return this.requestByIdAs(this.runtime, input);
+  }
+  async requestByIdAs(runtime, input) {
+    const workflow = this.getById(input.workflowId);
+    if (!workflow) {
+      throw new WorkflowValidationError(`[Sixb] Unknown workflow '${input.workflowId}'`);
+    }
+    return requestWorkflowRun(runtime, workflow, input);
+  }
+}
+export { WorkflowDefinitionError, WorkflowValidationError, isStepDefinition, isAgentStepDefinition, isInterventionDefinition, isWorkflowDefinition, validateWorkflowDefinition, validateWorkflowsAtStartup, validateWorkflowInput, validateWorkflowStepInput, validateWorkflowStepOutput, validateWorkflowInterventionInput, validateWorkflowInterventionResponse, validateWorkflowInterventionDefaultResponse, validateWorkflowAgentStepInput, validateWorkflowAgentStepOutput, interventionField, defineWorkflowStep, defineAgentStep, defineIntervention, defineWorkflow, snapshotWorkflowAgentStepInput, snapshotWorkflowAgentStepOutput, snapshotWorkflowInput, snapshotWorkflowStepInput, snapshotWorkflowStepOutput, snapshotWorkflowInterventionInput, snapshotWorkflowInterventionResponse, snapshotWorkflowInterventionDefaultResponse, snapshotWorkflowActionInput, requestWorkflowRun, WorkflowsRuntime };
+
+//# debugId=906B9CDA43F4388964756E2164756E21