@sixb/core 0.1.1 → 0.1.3

package/dist/chunk-btcsywk4.js

@@ -1,985 +0,0 @@
-// @bun
-import {
-  isScheduleDefinition
-} from "./chunk-867jxh7c.js";
-import {
-  isActionDefinition
-} from "./chunk-avppcgt6.js";
-import {
-  reportRunFailure
-} from "./chunk-t72dvahb.js";
-import {
-  isAgentDefinition
-} from "./chunk-86459jn0.js";
-import {
-  isObjectRefSchema,
-  validateSchemaOrRefValue
-} from "./chunk-md9jbrm9.js";
-import {
-  SYSTEM_PRINCIPAL
-} from "./chunk-xt6qx9sh.js";
-import {
-  assertAuthorized
-} from "./chunk-exrfbt2d.js";
-import {
-  isPlainRecord
-} from "./chunk-be9vm29v.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);
-}
-
-// 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=680E4CCE7DF2359264756E2164756E21