@aaac/contracts 0.0.1 → 0.1.1

package/dist/chunk-B7OY3RPU.js

@@ -0,0 +1,1287 @@
+// src/schema.ts
+import { z } from "zod";
+var SUPPORTED_SCHEMA_VERSIONS = ["aaac/0.1"];
+var SCHEMA_VERSION_PATTERN = /^aaac\/\d+\.\d+$/;
+var JSONSchemaRefSchema = z.union([
+  z.object({ schema: z.record(z.string(), z.unknown()) }),
+  z.object({ $ref: z.string() })
+]);
+var OptionSchema = z.object({
+  name: z.string().min(1),
+  schema: z.record(z.string(), z.unknown()),
+  required: z.boolean().optional(),
+  description: z.string().optional()
+});
+var ArtifactSlotValueSchema = z.union([
+  z.string(),
+  z.object({
+    artifact: z.string(),
+    direction: z.enum(["read", "write", "readwrite"])
+  })
+]);
+var OperationSchema = z.object({
+  description: z.string().min(1),
+  agentWorkflow: z.string().optional(),
+  agentTask: z.string().optional(),
+  handler: z.string().optional(),
+  options: z.array(OptionSchema).optional(),
+  input: JSONSchemaRefSchema.optional(),
+  output: z.object({
+    success: JSONSchemaRefSchema,
+    failed: JSONSchemaRefSchema.optional()
+  }),
+  artifactSlots: z.record(z.string(), ArtifactSlotValueSchema).optional(),
+  riskLevel: z.enum(["low", "medium", "high"]).optional(),
+  idempotent: z.boolean().optional(),
+  requiresConfirmation: z.boolean().optional(),
+  execution: z.object({
+    timeoutMs: z.number().optional(),
+    costCeilingUsd: z.number().optional()
+  }).optional(),
+  memoryRef: z.object({
+    input: z.boolean().optional(),
+    output: z.boolean().optional()
+  }).optional()
+}).superRefine((op, ctx) => {
+  const dispatchCount = [op.agentWorkflow, op.agentTask, op.handler].filter(
+    (v) => v !== void 0
+  ).length;
+  if (dispatchCount === 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Exactly one of agentWorkflow, agentTask, or handler must be specified",
+      path: ["agentWorkflow"]
+    });
+  } else if (dispatchCount > 1) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Only one of agentWorkflow, agentTask, or handler may be specified",
+      path: ["agentWorkflow"]
+    });
+  }
+});
+var ComponentSchema = z.object({
+  schema: z.string().regex(SCHEMA_VERSION_PATTERN, 'schema must match pattern "aaac/x.y"'),
+  info: z.object({
+    id: z.string().min(1),
+    version: z.string().min(1),
+    description: z.string().optional()
+  }),
+  implementation: z.string().optional(),
+  projections: z.array(
+    z.enum(["library", "cli", "mcp", "claude", "openai"])
+  ),
+  operations: z.record(z.string(), OperationSchema)
+}).superRefine((component, ctx) => {
+  const usesAgentic = Object.values(component.operations).some(
+    (op) => op.agentWorkflow !== void 0 || op.agentTask !== void 0
+  );
+  if (usesAgentic && !component.implementation) {
+    ctx.addIssue({
+      code: "custom",
+      message: "implementation is required when any operation uses agentWorkflow or agentTask",
+      path: ["implementation"]
+    });
+  }
+});
+
+// src/parser.ts
+import { readFile } from "fs/promises";
+import { parse as parseYaml } from "yaml";
+var ComponentParseError = class extends Error {
+  constructor(message, filePath, cause) {
+    super(filePath ? `${filePath}: ${message}` : message);
+    this.filePath = filePath;
+    this.cause = cause;
+    this.name = "ComponentParseError";
+  }
+  filePath;
+  cause;
+};
+function formatZodError(error, filePath) {
+  const prefix = filePath ? `${filePath}: ` : "";
+  const details = error.issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `${path}: ${issue.message}`;
+  }).join("; ");
+  return `${prefix}Validation failed: ${details}`;
+}
+function normalizeOperation(op) {
+  return {
+    description: op.description,
+    agentWorkflow: op.agentWorkflow ?? op.agent_workflow,
+    agentTask: op.agentTask ?? op.agent_task,
+    handler: op.handler,
+    options: op.options,
+    input: op.input,
+    output: op.output,
+    artifactSlots: op.artifactSlots ?? op.artifact_slots,
+    riskLevel: op.riskLevel ?? op.risk_level,
+    idempotent: op.idempotent,
+    requiresConfirmation: op.requiresConfirmation ?? op.requires_confirmation,
+    execution: op.execution,
+    memoryRef: op.memoryRef ?? op.memory_ref
+  };
+}
+function normalizeComponent(raw) {
+  const operations = raw.operations;
+  const normalizedOps = {};
+  if (operations && typeof operations === "object" && !Array.isArray(operations)) {
+    for (const [name, op] of Object.entries(operations)) {
+      if (op && typeof op === "object" && !Array.isArray(op)) {
+        normalizedOps[name] = normalizeOperation(op);
+      } else {
+        normalizedOps[name] = op;
+      }
+    }
+  }
+  return {
+    schema: raw.schema,
+    info: raw.info,
+    implementation: raw.implementation,
+    projections: raw.projections,
+    operations: Object.keys(normalizedOps).length > 0 ? normalizedOps : raw.operations
+  };
+}
+function validateComponent(raw, filePath) {
+  const normalized = raw && typeof raw === "object" && !Array.isArray(raw) ? normalizeComponent(raw) : raw;
+  const result = ComponentSchema.safeParse(normalized);
+  if (!result.success) {
+    throw new ComponentParseError(
+      formatZodError(result.error, filePath),
+      filePath,
+      result.error
+    );
+  }
+  return result.data;
+}
+function parseComponentString(content, filePath) {
+  let raw;
+  try {
+    raw = parseYaml(content);
+  } catch (err) {
+    throw new ComponentParseError(
+      `Invalid YAML: ${err.message}`,
+      filePath,
+      err
+    );
+  }
+  return validateComponent(raw, filePath);
+}
+async function parseComponentFile(filePath) {
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch (err) {
+    throw new ComponentParseError(
+      `Cannot read file: ${err.message}`,
+      filePath,
+      err
+    );
+  }
+  return parseComponentString(content, filePath);
+}
+
+// src/errors.ts
+var ComponentCompileError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ComponentCompileError";
+  }
+};
+var ComponentValidationError = class extends ComponentCompileError {
+  constructor(message) {
+    super(message);
+    this.name = "ComponentValidationError";
+  }
+};
+
+// src/ref-resolver.ts
+import { readFileSync } from "fs";
+import { resolve, dirname, extname } from "path";
+import { parse as parseYaml2 } from "yaml";
+var RefResolutionError = class extends Error {
+  constructor(ref, message) {
+    super(`Cannot resolve $ref "${ref}": ${message}`);
+    this.ref = ref;
+    this.name = "RefResolutionError";
+  }
+  ref;
+};
+function loadFile(filePath, fileCache) {
+  const absPath = resolve(filePath);
+  const cached = fileCache.get(absPath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  try {
+    const content = readFileSync(absPath, "utf-8");
+    const ext = extname(absPath).toLowerCase();
+    const parsed = ext === ".json" ? JSON.parse(content) : parseYaml2(content);
+    fileCache.set(absPath, parsed);
+    return parsed;
+  } catch (err) {
+    throw new RefResolutionError(
+      filePath,
+      `Cannot read external file: ${err.message}`
+    );
+  }
+}
+function resolveJsonPointer(root, pointer) {
+  const segments = pointer.split("/").filter((s) => s.length > 0).map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+  let current = root;
+  for (const segment of segments) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      throw new RefResolutionError(
+        `#${pointer}`,
+        `Cannot traverse into non-object at "${segment}"`
+      );
+    }
+    const obj = current;
+    if (!(segment in obj)) {
+      throw new RefResolutionError(`#${pointer}`, `Key "${segment}" not found`);
+    }
+    current = obj[segment];
+  }
+  return current;
+}
+function resolveExternalRef(ref, basePath, fileCache) {
+  const hashIndex = ref.indexOf("#/");
+  const filePart = hashIndex >= 0 ? ref.slice(0, hashIndex) : ref;
+  const pointer = hashIndex >= 0 ? ref.slice(hashIndex + 1) : null;
+  const absFilePath = resolve(basePath, filePart);
+  const externalDoc = loadFile(absFilePath, fileCache);
+  if (pointer) {
+    return resolveJsonPointer(externalDoc, pointer);
+  }
+  return externalDoc;
+}
+function resolveRefs(value, options = {}) {
+  const resolved = /* @__PURE__ */ new Set();
+  const fileCache = /* @__PURE__ */ new Map();
+  const basePath = options.basePath ?? process.cwd();
+  return deepResolve(value, value, resolved, basePath, fileCache);
+}
+function deepResolve(value, root, resolved, basePath, fileCache) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => deepResolve(item, root, resolved, basePath, fileCache)
+    );
+  }
+  const obj = value;
+  if ("$ref" in obj && typeof obj["$ref"] === "string") {
+    const ref = obj["$ref"];
+    if (ref.startsWith("#/")) {
+      if (resolved.has(ref)) {
+        throw new RefResolutionError(ref, "Circular reference detected");
+      }
+      resolved.add(ref);
+      const pointer = ref.slice(1);
+      const target2 = resolveJsonPointer(root, pointer);
+      const result3 = deepResolve(target2, root, resolved, basePath, fileCache);
+      resolved.delete(ref);
+      return result3;
+    }
+    if (resolved.has(ref)) {
+      throw new RefResolutionError(ref, "Circular reference detected");
+    }
+    resolved.add(ref);
+    const target = resolveExternalRef(ref, basePath, fileCache);
+    const hashIndex = ref.indexOf("#/");
+    const externalBasePath = hashIndex >= 0 ? dirname(resolve(basePath, ref.slice(0, hashIndex))) : dirname(resolve(basePath, ref));
+    const externalResolved = /* @__PURE__ */ new Set();
+    const result2 = deepResolve(
+      target,
+      target,
+      externalResolved,
+      externalBasePath,
+      fileCache
+    );
+    resolved.delete(ref);
+    return result2;
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(obj)) {
+    result[key] = deepResolve(val, root, resolved, basePath, fileCache);
+  }
+  return result;
+}
+
+// src/validation.ts
+import { access, readFile as readFile2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { parse as parseYaml3 } from "yaml";
+function extractIdsFromSection(section) {
+  if (!section || typeof section !== "object" || Array.isArray(section)) {
+    return [];
+  }
+  return Object.keys(section).filter(
+    (key) => key.length > 0
+  );
+}
+function extractImplementationIds(content) {
+  if (!content || typeof content !== "object" || Array.isArray(content)) {
+    return { workflowIds: [], taskIds: [] };
+  }
+  const doc = content;
+  return {
+    workflowIds: extractIdsFromSection(doc.workflows),
+    taskIds: extractIdsFromSection(doc.tasks)
+  };
+}
+async function fileExists(absolutePath) {
+  try {
+    await access(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadImplementationIds(implementationPath, basePath) {
+  const absolutePath = resolve2(basePath, implementationPath);
+  if (!await fileExists(absolutePath)) {
+    throw new ComponentValidationError(
+      `Implementation file not found: ${absolutePath}`
+    );
+  }
+  let content;
+  try {
+    content = await readFile2(absolutePath, "utf-8");
+  } catch (err) {
+    throw new ComponentValidationError(
+      `Cannot read implementation file ${absolutePath}: ${err.message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = parseYaml3(content);
+  } catch (err) {
+    throw new ComponentValidationError(
+      `Invalid YAML in implementation file ${absolutePath}: ${err.message}`
+    );
+  }
+  return extractImplementationIds(parsed);
+}
+function formatAvailableIds(label, ids) {
+  if (ids.length === 0) {
+    return `${label}: (none)`;
+  }
+  return `${label}: ${ids.join(", ")}`;
+}
+async function validateComponent2(ir, options) {
+  const usesAgentic = Object.values(ir.operations).some(
+    (op) => op.agentWorkflow !== void 0 || op.agentTask !== void 0
+  );
+  if (!ir.implementation) {
+    if (usesAgentic) {
+      throw new ComponentValidationError(
+        "implementation is required when any operation uses agentWorkflow or agentTask"
+      );
+    }
+    return;
+  }
+  const ids = await loadImplementationIds(ir.implementation, options.basePath);
+  for (const [operationName, op] of Object.entries(ir.operations)) {
+    if (op.agentWorkflow !== void 0) {
+      if (!ids.workflowIds.includes(op.agentWorkflow)) {
+        throw new ComponentValidationError(
+          `Operation "${operationName}": agentWorkflow "${op.agentWorkflow}" not found in implementation DSL. ${formatAvailableIds("Available workflows", ids.workflowIds)}`
+        );
+      }
+    }
+    if (op.agentTask !== void 0) {
+      if (!ids.taskIds.includes(op.agentTask)) {
+        throw new ComponentValidationError(
+          `Operation "${operationName}": agentTask "${op.agentTask}" not found in implementation DSL. ${formatAvailableIds("Available tasks", ids.taskIds)}`
+        );
+      }
+    }
+  }
+}
+
+// src/compiler.ts
+import { dirname as dirname2 } from "path";
+function assertSupportedSchemaVersion(schema) {
+  if (!SUPPORTED_SCHEMA_VERSIONS.includes(schema)) {
+    throw new ComponentCompileError(
+      `Unsupported schema version "${schema}". Supported: ${SUPPORTED_SCHEMA_VERSIONS.join(", ")}`
+    );
+  }
+}
+function toJSONSchemaRef(ref, basePath) {
+  let value = ref;
+  if (basePath) {
+    value = resolveRefs(ref, { basePath });
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    if ("schema" in obj && obj.schema && typeof obj.schema === "object") {
+      return { schema: obj.schema };
+    }
+    if ("$ref" in obj && typeof obj["$ref"] === "string") {
+      return { $ref: obj["$ref"] };
+    }
+    return obj;
+  }
+  return ref;
+}
+function normalizeArtifactSlots(slots) {
+  if (!slots) {
+    return {};
+  }
+  const result = {};
+  for (const [slotName, value] of Object.entries(slots)) {
+    if (typeof value === "string") {
+      result[slotName] = { artifact: value, direction: "readwrite" };
+    } else {
+      result[slotName] = {
+        artifact: value.artifact,
+        direction: value.direction
+      };
+    }
+  }
+  return result;
+}
+function asSchemaObject(ref) {
+  if (!ref) {
+    return void 0;
+  }
+  if ("schema" in ref && ref.schema && typeof ref.schema === "object") {
+    return ref.schema;
+  }
+  if (!("$ref" in ref)) {
+    return ref;
+  }
+  return void 0;
+}
+function extractFailureClasses(failedRef) {
+  const schema = asSchemaObject(failedRef);
+  if (!schema) {
+    return [];
+  }
+  const failureClasses = schema["failure_classes"];
+  if (Array.isArray(failureClasses)) {
+    return failureClasses.filter((v) => typeof v === "string");
+  }
+  const properties = schema["properties"];
+  if (properties && typeof properties === "object") {
+    const failureClass = properties["failure_class"];
+    if (failureClass && typeof failureClass === "object") {
+      const enumValues = failureClass["enum"];
+      if (Array.isArray(enumValues)) {
+        return enumValues.filter((v) => typeof v === "string");
+      }
+    }
+  }
+  const oneOf = schema["oneOf"];
+  if (Array.isArray(oneOf)) {
+    const classes = [];
+    for (const variant of oneOf) {
+      if (!variant || typeof variant !== "object") {
+        continue;
+      }
+      const obj = variant;
+      if (typeof obj["const"] === "string") {
+        classes.push(obj["const"]);
+        continue;
+      }
+      const props = obj["properties"];
+      if (props && typeof props === "object") {
+        const fc = props["failure_class"];
+        if (fc && typeof fc === "object") {
+          const c = fc["const"];
+          if (typeof c === "string") {
+            classes.push(c);
+          }
+        }
+      }
+    }
+    if (classes.length > 0) {
+      return classes;
+    }
+  }
+  return [];
+}
+function compileOption(opt) {
+  return {
+    name: opt.name,
+    schema: opt.schema,
+    required: opt.required ?? false,
+    description: opt.description
+  };
+}
+function compileOperation(op, basePath) {
+  const output = {
+    success: toJSONSchemaRef(op.output.success, basePath),
+    failed: op.output.failed ? toJSONSchemaRef(op.output.failed, basePath) : void 0
+  };
+  return {
+    description: op.description,
+    agentWorkflow: op.agentWorkflow,
+    agentTask: op.agentTask,
+    handler: op.handler,
+    options: (op.options ?? []).map(compileOption),
+    input: op.input ? toJSONSchemaRef(op.input, basePath) : void 0,
+    output,
+    errorModel: {
+      failureClasses: extractFailureClasses(output.failed)
+    },
+    artifactSlots: normalizeArtifactSlots(op.artifactSlots),
+    riskLevel: op.riskLevel ?? "medium",
+    idempotent: op.idempotent ?? false,
+    requiresConfirmation: op.requiresConfirmation ?? false,
+    execution: {
+      timeoutMs: op.execution?.timeoutMs,
+      costCeilingUsd: op.execution?.costCeilingUsd
+    },
+    memoryRef: op.memoryRef
+  };
+}
+function compileComponent(dsl, options = {}) {
+  assertSupportedSchemaVersion(dsl.schema);
+  const operations = {};
+  for (const [name, op] of Object.entries(dsl.operations)) {
+    operations[name] = compileOperation(op, options.basePath);
+  }
+  return {
+    schema: dsl.schema,
+    info: {
+      id: dsl.info.id,
+      version: dsl.info.version,
+      description: dsl.info.description
+    },
+    implementation: dsl.implementation,
+    projections: [...dsl.projections],
+    operations
+  };
+}
+async function maybeValidateComponent(ir, options) {
+  if (options.validate === false) {
+    return;
+  }
+  if (!options.basePath) {
+    return;
+  }
+  await validateComponent2(ir, { basePath: options.basePath });
+}
+async function compileComponentAsync(dsl, options = {}) {
+  const ir = compileComponent(dsl, options);
+  await maybeValidateComponent(ir, options);
+  return ir;
+}
+async function compileComponentFile(filePath, options = {}) {
+  const basePath = dirname2(filePath);
+  const dsl = await parseComponentFile(filePath);
+  const ir = compileComponent(dsl, { ...options, basePath });
+  await maybeValidateComponent(ir, { ...options, basePath });
+  return ir;
+}
+
+// src/generators/cli-generator.ts
+import { stringify as stringifyYaml } from "yaml";
+function unwrapSchema(ref) {
+  if (!ref) {
+    return void 0;
+  }
+  if ("schema" in ref && ref.schema && typeof ref.schema === "object") {
+    return ref.schema;
+  }
+  if ("$ref" in ref) {
+    return { $ref: ref.$ref };
+  }
+  return ref;
+}
+function buildEffects(artifactSlots) {
+  const reads = [];
+  const writes = [];
+  for (const [slotName, slot] of Object.entries(artifactSlots)) {
+    if (slot.direction === "read" || slot.direction === "readwrite") {
+      reads.push(slotName);
+    }
+    if (slot.direction === "write" || slot.direction === "readwrite") {
+      writes.push(slotName);
+    }
+  }
+  if (reads.length === 0 && writes.length === 0) {
+    return void 0;
+  }
+  const effects = {};
+  if (reads.length > 0) {
+    effects.reads = reads;
+  }
+  if (writes.length > 0) {
+    effects.writes = writes;
+  }
+  return effects;
+}
+function buildExits(op) {
+  const exits = {
+    "0": {
+      description: "Success"
+    }
+  };
+  const successSchema = unwrapSchema(op.output.success);
+  if (successSchema) {
+    exits["0"].stdout = {
+      format: "json",
+      schema: successSchema
+    };
+  }
+  const failedSchema = unwrapSchema(op.output.failed);
+  if (failedSchema) {
+    const exitCode = op.errorModel.failureClasses.length > 0 ? "1" : "1";
+    exits[exitCode] = {
+      description: "Operation failed",
+      stderr: {
+        format: "json",
+        schema: failedSchema
+      }
+    };
+  }
+  for (let i = 0; i < op.errorModel.failureClasses.length; i++) {
+    const code = String(i + 1);
+    if (!exits[code]) {
+      exits[code] = {
+        description: `Failure: ${op.errorModel.failureClasses[i]}`
+      };
+      if (failedSchema) {
+        exits[code].stderr = {
+          format: "json",
+          schema: failedSchema
+        };
+      }
+    }
+  }
+  return exits;
+}
+function buildCommand(operationName, op) {
+  const command = {
+    summary: op.description
+  };
+  if (Object.keys(op.artifactSlots).length > 0) {
+    const slots = {};
+    for (const [name, slot] of Object.entries(op.artifactSlots)) {
+      slots[name] = { direction: slot.direction };
+    }
+    command.artifact_slots = slots;
+  }
+  if (op.options.length > 0) {
+    command.options = op.options.map((opt) => {
+      const entry = {
+        name: opt.name,
+        schema: opt.schema
+      };
+      if (opt.description) {
+        entry.description = opt.description;
+      }
+      if (opt.required) {
+        entry.required = true;
+      }
+      return entry;
+    });
+  }
+  const inputSchema = unwrapSchema(op.input);
+  if (inputSchema) {
+    command.streams = {
+      stdin: { schema: inputSchema }
+    };
+  }
+  command.exits = buildExits(op);
+  const effects = buildEffects(op.artifactSlots);
+  if (effects) {
+    command.effects = effects;
+  }
+  const xAgent = {
+    risk_level: op.riskLevel,
+    requires_confirmation: op.requiresConfirmation,
+    idempotent: op.idempotent
+  };
+  if (op.agentWorkflow) {
+    xAgent.dsl_workflow = op.agentWorkflow;
+  }
+  if (op.agentTask) {
+    xAgent.dsl_task = op.agentTask;
+  }
+  if (op.execution.timeoutMs !== void 0) {
+    xAgent.expected_duration_ms = op.execution.timeoutMs;
+  }
+  command["x-agent"] = xAgent;
+  return command;
+}
+function buildCliContract(ir) {
+  const commands = {};
+  for (const [name, op] of Object.entries(ir.operations)) {
+    commands[name] = buildCommand(name, op);
+  }
+  return {
+    cli_contracts: "0.1.0",
+    info: {
+      title: ir.info.id,
+      version: ir.info.version,
+      description: ir.info.description ?? `${ir.info.id} component CLI`
+    },
+    command_sets: {
+      [ir.info.id]: {
+        summary: ir.info.description ?? ir.info.id,
+        global_options: [
+          {
+            name: "resume",
+            schema: { type: "string" },
+            description: "Resume from a previous memory_ref ID"
+          }
+        ],
+        commands
+      }
+    }
+  };
+}
+var CLI_STUB_CONTENT = `extends: ./generated/cli-contract.generated.yaml
+`;
+var cliGenerator = {
+  generate(ir, _options) {
+    const contract = buildCliContract(ir);
+    const yamlContent = `# Auto-generated by @aaac/contracts. Do not edit.
+${stringifyYaml(contract)}`;
+    const files = [
+      {
+        path: "generated/cli-contract.generated.yaml",
+        content: yamlContent,
+        overwrite: true
+      }
+    ];
+    if (ir.projections.includes("cli")) {
+      files.push({
+        path: "cli-contract.yaml",
+        content: CLI_STUB_CONTENT,
+        overwrite: false
+      });
+    }
+    return files;
+  }
+};
+
+// src/generators/schema-to-ts.ts
+function unwrapSchema2(ref) {
+  if (!ref) {
+    return void 0;
+  }
+  if ("schema" in ref && ref.schema && typeof ref.schema === "object") {
+    return ref.schema;
+  }
+  if ("$ref" in ref) {
+    return void 0;
+  }
+  return ref;
+}
+function isValidIdentifier(name) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+function quoteKey(name) {
+  return isValidIdentifier(name) ? name : JSON.stringify(name);
+}
+function toPascalCase(name) {
+  return name.split(/[-_]/).filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function jsonSchemaToTs(schema, indent, generated) {
+  if (!schema) {
+    return "unknown";
+  }
+  const enumValues = schema["enum"];
+  if (Array.isArray(enumValues) && enumValues.length > 0) {
+    return enumValues.map((v) => typeof v === "string" ? JSON.stringify(v) : String(v)).join(" | ");
+  }
+  const type = schema["type"];
+  if (type === "string") {
+    return "string";
+  }
+  if (type === "number" || type === "integer") {
+    return "number";
+  }
+  if (type === "boolean") {
+    return "boolean";
+  }
+  if (type === "array") {
+    const items = schema["items"];
+    if (items && typeof items === "object" && !Array.isArray(items)) {
+      return `${jsonSchemaToTs(items, indent, generated)}[]`;
+    }
+    return "unknown[]";
+  }
+  if (type === "object" || schema["properties"]) {
+    const properties = schema["properties"];
+    if (!properties || typeof properties !== "object") {
+      return "Record<string, unknown>";
+    }
+    const required = Array.isArray(schema["required"]) ? schema["required"] : [];
+    const lines = [];
+    for (const [propName, propSchema] of Object.entries(
+      properties
+    )) {
+      if (!propSchema || typeof propSchema !== "object") {
+        continue;
+      }
+      const optional = required.includes(propName) ? "" : "?";
+      const tsType = jsonSchemaToTs(
+        propSchema,
+        indent + "  ",
+        generated
+      );
+      lines.push(`${indent}  ${quoteKey(propName)}${optional}: ${tsType};`);
+    }
+    if (lines.length === 0) {
+      return "Record<string, unknown>";
+    }
+    return `{
+${lines.join("\n")}
+${indent}}`;
+  }
+  return "unknown";
+}
+function schemaRefToTsType(ref, fallback = "unknown") {
+  return jsonSchemaToTs(unwrapSchema2(ref), "", /* @__PURE__ */ new Set()) || fallback;
+}
+function operationTypeNames(operationName) {
+  const base = toPascalCase(operationName);
+  return {
+    input: `${base}Input`,
+    output: `${base}Output`,
+    options: `${base}Options`,
+    failure: `${base}Failure`,
+    failureClass: `${base}FailureClass`
+  };
+}
+function interfaceFromSchema(name, ref, fallbackBody) {
+  const schema = unwrapSchema2(ref);
+  if (!schema) {
+    return void 0;
+  }
+  const body = jsonSchemaToTs(schema, "", /* @__PURE__ */ new Set());
+  if (body === "unknown" && !schema["properties"]) {
+    return `export type ${name} = ${fallbackBody};
+`;
+  }
+  if (body.startsWith("{")) {
+    return `export interface ${name} ${body}
+`;
+  }
+  return `export type ${name} = ${body};
+`;
+}
+
+// src/generators/client-generator.ts
+var clientGenerator = {
+  generate(ir, _options) {
+    const functions = Object.keys(ir.operations).map((operationName) => {
+      const names = operationTypeNames(operationName);
+      return `export async function ${operationName}(
+  options: ${names.options},
+  input: ${names.input},
+  ctx: AaacInvocationContext,
+  memoryRef?: string,
+): Promise<${names.output}> {
+  return runtime.execute(${JSON.stringify(operationName)}, options, input, ctx, memoryRef);
+}`;
+    });
+    const content = `/** Auto-generated by @aaac/contracts. Do not edit. */
+/* eslint-disable */
+
+import type {
+${Object.keys(ir.operations).flatMap((name) => {
+      const n = operationTypeNames(name);
+      const types = [n.input, n.output, n.options];
+      return types.map((t) => `  ${t},`);
+    }).join("\n")}
+} from "./component.types.js";
+import { runtime, type AaacInvocationContext } from "./component.runtime.js";
+
+${functions.join("\n\n")}
+`;
+    return [
+      {
+        path: "generated/component.client.ts",
+        content,
+        overwrite: true
+      }
+    ];
+  }
+};
+
+// src/generators/handler-generator.ts
+import { existsSync } from "fs";
+import { join, relative, dirname as dirname3 } from "path";
+function typesImportPath(handlerPath) {
+  const handlerDir = dirname3(handlerPath);
+  const rel = relative(handlerDir, "generated/component.types");
+  const importPath = rel.startsWith(".") ? rel : `./${rel}`;
+  return `${importPath}.js`;
+}
+function buildHandlerSkeleton(operationName, handlerPath) {
+  const names = operationTypeNames(operationName);
+  const typesImport = typesImportPath(handlerPath);
+  return `/** Handler skeleton \u2014 implement the logic below. */
+/* eslint-disable */
+
+import type { ${names.input}, ${names.output} } from "${typesImport}";
+
+export async function ${operationName}(
+  input: ${names.input},
+): Promise<${names.output}> {
+  // TODO: implement
+  throw new Error("Not implemented: ${operationName}");
+}
+`;
+}
+var handlerGenerator = {
+  generate(ir, options) {
+    const files = [];
+    for (const [operationName, op] of Object.entries(ir.operations)) {
+      if (!op.handler) {
+        continue;
+      }
+      const absPath = join(options.outputDir, op.handler);
+      if (existsSync(absPath)) {
+        files.push({
+          path: op.handler,
+          content: "",
+          overwrite: false,
+          warning: `Handler file already exists, skipping: ${op.handler}`
+        });
+        continue;
+      }
+      files.push({
+        path: op.handler,
+        content: buildHandlerSkeleton(operationName, op.handler),
+        overwrite: false
+      });
+    }
+    return files;
+  }
+};
+
+// src/generators/runtime-generator.ts
+import { relative as relative2, dirname as dirname4, join as join2 } from "path";
+function handlerImportPath(handlerPath, outputDir) {
+  const fromGenerated = join2(outputDir, "generated", "component.runtime.ts");
+  const absHandler = join2(outputDir, handlerPath);
+  let importPath = relative2(dirname4(fromGenerated), absHandler);
+  if (!importPath.startsWith(".")) {
+    importPath = `./${importPath}`;
+  }
+  return importPath.replace(/\.ts$/, ".js");
+}
+function dispatchBody(operationName, op, outputDir) {
+  const names = operationTypeNames(operationName);
+  const imports = [];
+  if (op.agentWorkflow) {
+    return {
+      imports,
+      caseBody: `      ctx.policy?.assertAllowed(${JSON.stringify(operationName)});
+      return ctx.runtime.runWorkflow(${JSON.stringify(op.agentWorkflow)}, {
+        options,
+        input,
+        observer: ctx.observer,
+        abortSignal: ctx.abortSignal,
+      });`
+    };
+  }
+  if (op.agentTask) {
+    return {
+      imports,
+      caseBody: `      ctx.policy?.assertAllowed(${JSON.stringify(operationName)});
+      return ctx.runtime.runTask(${JSON.stringify(op.agentTask)}, {
+        options,
+        input,
+        observer: ctx.observer,
+        abortSignal: ctx.abortSignal,
+      });`
+    };
+  }
+  if (op.handler) {
+    const importPath = handlerImportPath(op.handler, outputDir);
+    imports.push(
+      `import { ${operationName} } from ${JSON.stringify(importPath)};`
+    );
+    return {
+      imports,
+      caseBody: `      ctx.policy?.assertAllowed(${JSON.stringify(operationName)});
+      return ${operationName}(input);`
+    };
+  }
+  return {
+    imports,
+    caseBody: `      throw new Error("No dispatch target for operation ${operationName}");`
+  };
+}
+var runtimeGenerator = {
+  generate(ir, options) {
+    const componentConst = `${toPascalCase(ir.info.id)}Component`;
+    const allImports = [];
+    const cases = [];
+    for (const [operationName, op] of Object.entries(ir.operations)) {
+      const names = operationTypeNames(operationName);
+      const { imports, caseBody } = dispatchBody(
+        operationName,
+        op,
+        options.outputDir
+      );
+      allImports.push(...imports);
+      cases.push(`    case ${JSON.stringify(operationName)}:
+${caseBody}
+`);
+    }
+    const uniqueImports = [...new Set(allImports)];
+    const content = `/** Auto-generated by @aaac/contracts. Do not edit. */
+/* eslint-disable */
+
+import { createRuntimeBinding } from "@aaac/runtime";
+import type {
+${Object.keys(ir.operations).flatMap((name) => {
+      const n = operationTypeNames(name);
+      return [`  ${n.input},`, `  ${n.output},`, `  ${n.options},`];
+    }).join("\n")}
+} from "./component.types.js";
+${uniqueImports.length > 0 ? `${uniqueImports.join("\n")}
+` : ""}
+export interface AaacInvocationContext {
+  runtime: {
+    runWorkflow(workflowId: string, args: unknown): Promise<unknown>;
+    runTask(taskId: string, args: unknown): Promise<unknown>;
+  };
+  policy?: {
+    assertAllowed(operationName: string): void;
+  };
+  observer?: unknown;
+  abortSignal?: AbortSignal;
+}
+
+const ${componentConst} = ${JSON.stringify(
+      { id: ir.info.id, version: ir.info.version },
+      null,
+      2
+    )} as const;
+
+function applyMemoryRef(
+  ctx: AaacInvocationContext,
+  memoryRef?: string,
+): AaacInvocationContext {
+  if (!memoryRef) {
+    return ctx;
+  }
+  return {
+    ...ctx,
+    memoryRef: {
+      id: memoryRef,
+      provider: "aaac",
+      compat: "v1",
+      created_at: new Date().toISOString(),
+    },
+  };
+}
+
+async function dispatchExecute(
+  operationName: string,
+  options: Record<string, unknown>,
+  input: unknown,
+  ctx: AaacInvocationContext,
+): Promise<unknown> {
+  switch (operationName) {
+${cases.join("")}
+    default:
+      throw new Error(\`Unknown operation: \${operationName}\`);
+  }
+}
+
+const _binding = createRuntimeBinding(${componentConst}, {
+  execute: dispatchExecute,
+});
+
+export const runtime = {
+  getOperationNames(): string[] {
+    return _binding.getOperationNames();
+  },
+  getOperationIR(name: string) {
+    return _binding.getOperationIR(name);
+  },
+  execute(
+    operationName: string,
+    options: Record<string, unknown>,
+    input: unknown,
+    ctx: AaacInvocationContext,
+    memoryRef?: string,
+  ): Promise<unknown> {
+    return _binding.execute(
+      operationName,
+      options,
+      input,
+      applyMemoryRef(ctx, memoryRef),
+    );
+  },
+};
+`;
+    return [
+      {
+        path: "generated/component.runtime.ts",
+        content,
+        overwrite: true
+      }
+    ];
+  }
+};
+
+// src/generators/types-generator.ts
+function generateOperationTypes(operationName, op) {
+  const names = operationTypeNames(operationName);
+  const parts = [];
+  if (op.input) {
+    const iface = interfaceFromSchema(
+      names.input,
+      op.input,
+      "Record<string, unknown>"
+    );
+    parts.push(iface ?? `export type ${names.input} = Record<string, unknown>;
+`);
+  } else {
+    parts.push(`export type ${names.input} = Record<string, unknown>;
+`);
+  }
+  const outputIface = interfaceFromSchema(
+    names.output,
+    op.output.success,
+    "unknown"
+  );
+  parts.push(outputIface ?? `export type ${names.output} = unknown;
+`);
+  if (op.options.length > 0) {
+    const fields = op.options.map((opt) => {
+      const fieldName = opt.name.includes("-") || opt.name.includes("_") ? JSON.stringify(opt.name) : opt.name;
+      const optional = opt.required ? "" : "?";
+      const tsType = schemaRefToTsType({ schema: opt.schema });
+      const desc = opt.description ? `  /** ${opt.description} */
+` : "";
+      return `${desc}  ${fieldName}${optional}: ${tsType};`;
+    });
+    parts.push(`export interface ${names.options} {
+${fields.join("\n")}
+}
+`);
+  } else {
+    parts.push(`export type ${names.options} = Record<string, never>;
+`);
+  }
+  if (op.output.failed) {
+    const failureIface = interfaceFromSchema(
+      names.failure,
+      op.output.failed,
+      "unknown"
+    );
+    parts.push(failureIface ?? `export type ${names.failure} = unknown;
+`);
+  }
+  if (op.errorModel.failureClasses.length > 0) {
+    const union = op.errorModel.failureClasses.map((c) => JSON.stringify(c)).join(" | ");
+    parts.push(`export type ${names.failureClass} = ${union};
+`);
+  }
+  return parts.join("\n");
+}
+var typesGenerator = {
+  generate(ir, _options) {
+    const operationBlocks = Object.entries(ir.operations).map(
+      ([name, op]) => generateOperationTypes(name, op)
+    );
+    const content = `/** Auto-generated by @aaac/contracts. Do not edit. */
+/* eslint-disable */
+
+${operationBlocks.join("\n")}
+`;
+    return [
+      {
+        path: "generated/component.types.ts",
+        content,
+        overwrite: true
+      }
+    ];
+  }
+};
+
+// src/generators/index.ts
+import { mkdir, writeFile, access as access2 } from "fs/promises";
+import { dirname as dirname5, join as join3 } from "path";
+var ALL_GENERATORS = [
+  typesGenerator,
+  clientGenerator,
+  runtimeGenerator,
+  cliGenerator,
+  handlerGenerator
+];
+function generateAll(ir, options) {
+  return ALL_GENERATORS.flatMap((gen) => gen.generate(ir, options));
+}
+async function fileExists2(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeGeneratedFiles(files, outputDir) {
+  const written = [];
+  const skipped = [];
+  const warnings = [];
+  for (const file of files) {
+    const targetPath = join3(outputDir, file.path);
+    if (file.warning) {
+      warnings.push(file.warning);
+    }
+    if (!file.overwrite && await fileExists2(targetPath)) {
+      skipped.push(file.path);
+      continue;
+    }
+    if (!file.content && !file.overwrite) {
+      skipped.push(file.path);
+      continue;
+    }
+    await mkdir(dirname5(targetPath), { recursive: true });
+    await writeFile(targetPath, file.content, "utf-8");
+    written.push(file.path);
+  }
+  return { written, skipped, warnings };
+}
+
+export {
+  SUPPORTED_SCHEMA_VERSIONS,
+  SCHEMA_VERSION_PATTERN,
+  JSONSchemaRefSchema,
+  OptionSchema,
+  ArtifactSlotValueSchema,
+  OperationSchema,
+  ComponentSchema,
+  ComponentParseError,
+  parseComponentString,
+  parseComponentFile,
+  ComponentCompileError,
+  ComponentValidationError,
+  RefResolutionError,
+  resolveRefs,
+  extractImplementationIds,
+  validateComponent2 as validateComponent,
+  extractFailureClasses,
+  compileComponent,
+  compileComponentAsync,
+  compileComponentFile,
+  cliGenerator,
+  clientGenerator,
+  handlerGenerator,
+  runtimeGenerator,
+  typesGenerator,
+  generateAll,
+  writeGeneratedFiles
+};
+//# sourceMappingURL=chunk-B7OY3RPU.js.map