@manifesto-ai/codegen 0.1.4 → 0.1.5

package/dist/index.js

@@ -179,7 +179,9 @@ async function generate(opts) {
   if (hasErrors) {
     return { files, artifacts: allArtifacts, diagnostics };
   }
-  await fs.rm(opts.outDir, { recursive: true, force: true });
+  if (opts.cleanOutDir) {
+    await fs.rm(opts.outDir, { recursive: true, force: true });
+  }
   const header = generateHeader({
     sourceId: opts.sourceId,
     schemaHash: opts.schema.hash,
@@ -215,13 +217,770 @@ function validatePluginNames(plugins) {
   return void 0;
 }
 
+// src/plugins/domain-type-model.ts
+var UNKNOWN_TYPE = { kind: "unknown" };
+var NULL_TYPE = { kind: "primitive", type: "null" };
+function unknownType() {
+  return UNKNOWN_TYPE;
+}
+function primitiveType(type) {
+  return type === "null" ? NULL_TYPE : { kind: "primitive", type };
+}
+function literalType(value) {
+  return value === null ? NULL_TYPE : { kind: "literal", value };
+}
+function arrayType(element) {
+  return { kind: "array", element };
+}
+function tupleType(elements) {
+  return { kind: "tuple", elements };
+}
+function objectType(fields) {
+  return { kind: "object", fields };
+}
+function recordType(key, value) {
+  return { kind: "record", key, value };
+}
+function fieldSpecToDomainField(spec) {
+  return {
+    type: fieldSpecToDomainType(spec),
+    optional: !spec.required
+  };
+}
+function fieldSpecToDomainType(spec) {
+  let base;
+  if (typeof spec.type === "object" && "enum" in spec.type) {
+    base = unionOf(
+      spec.type.enum.map((value) => literalValueToType(value))
+    );
+  } else {
+    switch (spec.type) {
+      case "string":
+        base = primitiveType("string");
+        break;
+      case "number":
+        base = primitiveType("number");
+        break;
+      case "boolean":
+        base = primitiveType("boolean");
+        break;
+      case "null":
+        base = NULL_TYPE;
+        break;
+      case "object":
+        if (spec.fields) {
+          const fields = {};
+          for (const name of Object.keys(spec.fields)) {
+            fields[name] = fieldSpecToDomainField(spec.fields[name]);
+          }
+          base = objectType(fields);
+          break;
+        }
+        base = recordType(primitiveType("string"), unknownType());
+        break;
+      case "array":
+        base = arrayType(
+          spec.items ? fieldSpecToDomainType(spec.items) : unknownType()
+        );
+        break;
+      default:
+        base = unknownType();
+        break;
+    }
+  }
+  return spec.required ? base : unionOf([base, NULL_TYPE]);
+}
+function literalValueToType(value) {
+  if (value === null) {
+    return NULL_TYPE;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return literalType(value);
+  }
+  if (Array.isArray(value)) {
+    return arrayType(
+      value.length === 0 ? unknownType() : unionOf(value.map((item) => literalValueToType(item)))
+    );
+  }
+  if (isPlainObject(value)) {
+    const fields = {};
+    for (const name of Object.keys(value)) {
+      fields[name] = {
+        type: literalValueToType(value[name]),
+        optional: false
+      };
+    }
+    return objectType(fields);
+  }
+  return unknownType();
+}
+function unionOf(types) {
+  const flattened = [];
+  for (const type of types) {
+    if (type.kind === "unknown") {
+      return type;
+    }
+    if (type.kind === "union") {
+      flattened.push(...type.types);
+      continue;
+    }
+    flattened.push(type);
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const type of flattened) {
+    unique.set(stableTypeKey(type), type);
+  }
+  const deduped = Array.from(unique.values());
+  if (deduped.length === 0) {
+    return unknownType();
+  }
+  if (deduped.length === 1) {
+    return deduped[0];
+  }
+  return { kind: "union", types: deduped };
+}
+function removeNullType(type) {
+  switch (type.kind) {
+    case "primitive":
+      return type.type === "null" ? [] : [type];
+    case "literal":
+      return type.value === null ? [] : [type];
+    case "union":
+      return type.types.flatMap((member) => removeNullType(member));
+    default:
+      return [type];
+  }
+}
+function renderDomainType(type) {
+  switch (type.kind) {
+    case "unknown":
+      return "unknown";
+    case "primitive":
+      return type.type;
+    case "literal":
+      return renderLiteral(type.value);
+    case "array":
+      return `${wrapArrayElement(renderDomainType(type.element), type.element)}[]`;
+    case "tuple":
+      return `[${type.elements.map((element) => renderDomainType(element)).join(", ")}]`;
+    case "object": {
+      const fieldNames = Object.keys(type.fields).sort();
+      if (fieldNames.length === 0) {
+        return "{}";
+      }
+      const parts = fieldNames.map((name) => {
+        const field = type.fields[name];
+        const optional = field.optional ? "?" : "";
+        return `${name}${optional}: ${renderDomainType(field.type)}`;
+      });
+      return `{ ${parts.join("; ")} }`;
+    }
+    case "record":
+      return `Record<${renderDomainType(type.key)}, ${renderDomainType(type.value)}>`;
+    case "union":
+      return type.types.map((member) => renderDomainType(member)).join(" | ");
+  }
+}
+function wrapArrayElement(rendered, type) {
+  if (type.kind === "union") {
+    return `(${rendered})`;
+  }
+  return rendered;
+}
+function renderLiteral(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function stableTypeKey(type) {
+  switch (type.kind) {
+    case "unknown":
+      return "unknown";
+    case "primitive":
+      return `primitive:${type.type}`;
+    case "literal":
+      return `literal:${JSON.stringify(type.value)}`;
+    case "array":
+      return `array:${stableTypeKey(type.element)}`;
+    case "tuple":
+      return `tuple:${type.elements.map((element) => stableTypeKey(element)).join(",")}`;
+    case "object": {
+      const keys = Object.keys(type.fields).sort();
+      const fields = keys.map((name) => {
+        const field = type.fields[name];
+        return `${name}:${field.optional ? "?" : ""}${stableTypeKey(field.type)}`;
+      });
+      return `object:${fields.join(",")}`;
+    }
+    case "record":
+      return `record:${stableTypeKey(type.key)}:${stableTypeKey(type.value)}`;
+    case "union":
+      return `union:${type.types.map((member) => stableTypeKey(member)).sort().join("|")}`;
+  }
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/plugins/domain-type-inference.ts
+var META_TYPE = objectType({
+  actionName: { type: primitiveType("string"), optional: false },
+  intentId: { type: primitiveType("string"), optional: false },
+  timestamp: { type: primitiveType("number"), optional: false }
+});
+function createInferenceContext(schema, diagnostics, pluginName) {
+  return {
+    schema,
+    pluginName,
+    diagnostics,
+    warnedMessages: /* @__PURE__ */ new Set(),
+    computedCache: /* @__PURE__ */ new Map(),
+    computedInFlight: /* @__PURE__ */ new Set()
+  };
+}
+function inferComputedType(name, ctx) {
+  if (ctx.computedCache.has(name)) {
+    return ctx.computedCache.get(name) ?? unknownType();
+  }
+  const spec = ctx.schema.computed.fields[name];
+  if (!spec) {
+    warn(ctx, `Unknown computed field "${name}". Emitting "unknown".`);
+    return unknownType();
+  }
+  if (ctx.computedInFlight.has(name)) {
+    warn(ctx, `Recursive computed field "${name}" could not be inferred. Emitting "unknown".`);
+    return unknownType();
+  }
+  ctx.computedInFlight.add(name);
+  const inferred = inferExprType(spec.expr, ctx, /* @__PURE__ */ new Map());
+  ctx.computedInFlight.delete(name);
+  ctx.computedCache.set(name, inferred);
+  return inferred;
+}
+function inferExprType(expr, ctx, env = /* @__PURE__ */ new Map()) {
+  switch (expr.kind) {
+    case "lit":
+      return literalValueToType(expr.value);
+    case "get":
+      return inferPathType(expr.path, ctx, env);
+    case "eq":
+    case "neq":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+    case "and":
+    case "or":
+    case "not":
+    case "startsWith":
+    case "endsWith":
+    case "strIncludes":
+    case "includes":
+    case "every":
+    case "some":
+    case "hasKey":
+    case "isNull":
+    case "toBoolean":
+      return primitiveType("boolean");
+    case "add":
+    case "sub":
+    case "mul":
+    case "div":
+    case "mod":
+    case "min":
+    case "max":
+    case "abs":
+    case "neg":
+    case "floor":
+    case "ceil":
+    case "round":
+    case "sqrt":
+    case "pow":
+    case "sumArray":
+    case "strLen":
+    case "len":
+    case "indexOf":
+    case "toNumber":
+      return primitiveType("number");
+    case "concat":
+    case "substring":
+    case "trim":
+    case "toLowerCase":
+    case "toUpperCase":
+    case "replace":
+    case "typeof":
+    case "toString":
+      return primitiveType("string");
+    case "if":
+      return unionOf([
+        inferExprType(expr.then, ctx, env),
+        inferExprType(expr.else, ctx, env)
+      ]);
+    case "split":
+      return arrayType(primitiveType("string"));
+    case "at":
+      return unionOf([inferIndexedAccessType(expr.array, ctx, env), primitiveType("null")]);
+    case "first":
+    case "last":
+    case "minArray":
+    case "maxArray":
+      return unionOf([inferCollectionElementType(expr.array, ctx, env), primitiveType("null")]);
+    case "slice":
+    case "reverse":
+    case "unique":
+      return inferArrayLikeType(expr.array, ctx, env);
+    case "filter": {
+      const elementType = inferCollectionElementType(expr.array, ctx, env);
+      const nextEnv = withCollectionEnv(env, elementType);
+      inferExprType(expr.predicate, ctx, nextEnv);
+      return arrayType(elementType);
+    }
+    case "map": {
+      const elementType = inferCollectionElementType(expr.array, ctx, env);
+      const nextEnv = withCollectionEnv(env, elementType);
+      return arrayType(inferExprType(expr.mapper, ctx, nextEnv));
+    }
+    case "find": {
+      const elementType = inferCollectionElementType(expr.array, ctx, env);
+      const nextEnv = withCollectionEnv(env, elementType);
+      inferExprType(expr.predicate, ctx, nextEnv);
+      return unionOf([elementType, primitiveType("null")]);
+    }
+    case "append": {
+      const baseArray = inferArrayLikeType(expr.array, ctx, env);
+      const baseElement = getArrayElementType(baseArray);
+      const itemTypes = expr.items.map((item) => inferExprType(item, ctx, env));
+      return arrayType(unionOf([baseElement, ...itemTypes]));
+    }
+    case "flat":
+      return inferFlatType(expr.array, ctx, env);
+    case "object": {
+      const fields = {};
+      for (const name of Object.keys(expr.fields)) {
+        fields[name] = {
+          type: inferExprType(expr.fields[name], ctx, env),
+          optional: false
+        };
+      }
+      return objectType(fields);
+    }
+    case "field":
+      return inferFieldType(inferExprType(expr.object, ctx, env), expr.property);
+    case "keys":
+      return arrayType(primitiveType("string"));
+    case "values":
+      return arrayType(inferObjectValueType(inferExprType(expr.obj, ctx, env)));
+    case "entries":
+      return arrayType(
+        tupleType([
+          primitiveType("string"),
+          inferObjectValueType(inferExprType(expr.obj, ctx, env))
+        ])
+      );
+    case "merge":
+      return inferMergeType(
+        expr.objects.map((objectExpr) => inferExprType(objectExpr, ctx, env))
+      );
+    case "pick":
+      return inferPickLikeType(expr.obj, expr.keys, false, ctx, env);
+    case "omit":
+      return inferPickLikeType(expr.obj, expr.keys, true, ctx, env);
+    case "fromEntries":
+      return inferFromEntriesType(expr.entries, ctx, env);
+    case "coalesce": {
+      const members = expr.args.flatMap(
+        (arg) => removeNullType(inferExprType(arg, ctx, env))
+      );
+      return members.length === 0 ? primitiveType("null") : unionOf(members);
+    }
+    default:
+      warn(ctx, `Unsupported expression kind "${expr.kind}". Emitting "unknown".`);
+      return unknownType();
+  }
+}
+function inferPathType(path, ctx, env) {
+  const [head, ...tail] = path.split(".");
+  if (!head) {
+    warn(ctx, `Empty get() path encountered. Emitting "unknown".`);
+    return unknownType();
+  }
+  let base = env.get(head);
+  if (!base) {
+    if (head === "meta") {
+      base = META_TYPE;
+    } else if (Object.hasOwn(ctx.schema.state.fields, head)) {
+      base = fieldSpecToDomainType(ctx.schema.state.fields[head]);
+    } else if (Object.hasOwn(ctx.schema.computed.fields, head)) {
+      base = inferComputedType(head, ctx);
+    }
+  }
+  if (!base) {
+    warn(ctx, `Unknown get() path "${path}". Emitting "unknown".`);
+    return unknownType();
+  }
+  return walkPathType(base, tail);
+}
+function walkPathType(base, segments) {
+  let current = base;
+  for (const segment of segments) {
+    current = accessSegmentType(current, segment);
+  }
+  return current;
+}
+function accessSegmentType(base, segment) {
+  switch (base.kind) {
+    case "object":
+      return Object.hasOwn(base.fields, segment) ? base.fields[segment].type : unknownType();
+    case "record":
+      return unionOf([base.value, primitiveType("null")]);
+    case "array":
+      return isNumericSegment(segment) ? unionOf([base.element, primitiveType("null")]) : unknownType();
+    case "tuple":
+      return isNumericSegment(segment) ? base.elements[Number(segment)] ?? unknownType() : unknownType();
+    case "union":
+      return unionIgnoringUnknown(
+        base.types.map((member) => accessSegmentType(member, segment))
+      );
+    default:
+      return unknownType();
+  }
+}
+function inferIndexedAccessType(expr, ctx, env) {
+  const base = inferExprType(expr, ctx, env);
+  switch (base.kind) {
+    case "array":
+      return base.element;
+    case "tuple":
+      return unionOf(base.elements);
+    case "record":
+      return base.value;
+    case "union":
+      return unionOf(base.types.map((member) => inferIndexedAccessFromType(member)));
+    default:
+      return unknownType();
+  }
+}
+function inferIndexedAccessFromType(type) {
+  switch (type.kind) {
+    case "array":
+      return type.element;
+    case "tuple":
+      return unionOf(type.elements);
+    case "record":
+      return type.value;
+    default:
+      return unknownType();
+  }
+}
+function inferCollectionElementType(expr, ctx, env) {
+  return getArrayElementType(inferExprType(expr, ctx, env));
+}
+function getArrayElementType(type) {
+  switch (type.kind) {
+    case "array":
+      return type.element;
+    case "tuple":
+      return unionOf(type.elements);
+    case "union":
+      return unionOf(type.types.map((member) => getArrayElementType(member)));
+    default:
+      return unknownType();
+  }
+}
+function inferArrayLikeType(expr, ctx, env) {
+  const inferred = inferExprType(expr, ctx, env);
+  switch (inferred.kind) {
+    case "array":
+      return inferred;
+    case "tuple":
+      return arrayType(unionOf(inferred.elements));
+    case "union": {
+      const arrays = inferred.types.map((member) => inferArrayLikeFromType(member)).filter((member) => member.kind !== "unknown");
+      return arrays.length === 0 ? arrayType(unknownType()) : unionOf(arrays);
+    }
+    default:
+      return arrayType(unknownType());
+  }
+}
+function inferArrayLikeFromType(type) {
+  switch (type.kind) {
+    case "array":
+      return type;
+    case "tuple":
+      return arrayType(unionOf(type.elements));
+    default:
+      return unknownType();
+  }
+}
+function inferFlatType(expr, ctx, env) {
+  const outer = inferArrayLikeType(expr, ctx, env);
+  const outerElement = getArrayElementType(outer);
+  switch (outerElement.kind) {
+    case "array":
+      return arrayType(outerElement.element);
+    case "tuple":
+      return arrayType(unionOf(outerElement.elements));
+    case "union": {
+      const flatMembers = [];
+      for (const member of outerElement.types) {
+        if (member.kind === "array") {
+          flatMembers.push(member.element);
+          continue;
+        }
+        if (member.kind === "tuple") {
+          flatMembers.push(unionOf(member.elements));
+          continue;
+        }
+        flatMembers.push(member);
+      }
+      return arrayType(unionOf(flatMembers));
+    }
+    default:
+      return arrayType(outerElement);
+  }
+}
+function inferFieldType(base, property) {
+  switch (base.kind) {
+    case "object":
+      return Object.hasOwn(base.fields, property) ? base.fields[property].type : primitiveType("null");
+    case "record":
+      return unionOf([base.value, primitiveType("null")]);
+    case "union":
+      return unionOf(base.types.map((member) => inferFieldType(member, property)));
+    default:
+      return primitiveType("null");
+  }
+}
+function inferObjectValueType(type) {
+  switch (type.kind) {
+    case "object": {
+      const values = Object.keys(type.fields).map((name) => type.fields[name].type);
+      return values.length === 0 ? unknownType() : unionOf(values);
+    }
+    case "record":
+      return type.value;
+    case "union":
+      return unionOf(type.types.map((member) => inferObjectValueType(member)));
+    default:
+      return unknownType();
+  }
+}
+function inferMergeType(types) {
+  const fields = {};
+  let sawObject = false;
+  for (const type of types) {
+    if (type.kind !== "object") {
+      continue;
+    }
+    sawObject = true;
+    for (const name of Object.keys(type.fields)) {
+      fields[name] = type.fields[name];
+    }
+  }
+  return sawObject ? objectType(fields) : objectType({});
+}
+function inferPickLikeType(objectExpr, keysExpr, omit, ctx, env) {
+  const base = inferExprType(objectExpr, ctx, env);
+  if (base.kind !== "object") {
+    return objectType({});
+  }
+  const keys = readStringArrayLiteral(keysExpr);
+  if (!keys) {
+    return base;
+  }
+  const selected = new Set(keys);
+  const fields = {};
+  for (const name of Object.keys(base.fields)) {
+    const shouldInclude = omit ? !selected.has(name) : selected.has(name);
+    if (shouldInclude) {
+      fields[name] = base.fields[name];
+    }
+  }
+  return objectType(fields);
+}
+function inferFromEntriesType(entriesExpr, ctx, env) {
+  const literalEntries = readLiteralEntries(entriesExpr);
+  if (literalEntries) {
+    const valueTypes = literalEntries.map(([, value]) => literalValueToType(value));
+    return recordType(primitiveType("string"), unionOf(valueTypes));
+  }
+  const entriesType = inferExprType(entriesExpr, ctx, env);
+  const elementType = getArrayElementType(entriesType);
+  if (elementType.kind === "tuple" && elementType.elements.length >= 2) {
+    return recordType(primitiveType("string"), elementType.elements[1]);
+  }
+  return recordType(primitiveType("string"), unknownType());
+}
+function withCollectionEnv(env, itemType) {
+  const next = new Map(env);
+  next.set("$index", primitiveType("number"));
+  next.set("$item", itemType);
+  return next;
+}
+function readStringArrayLiteral(expr) {
+  if (expr.kind !== "lit" || !Array.isArray(expr.value)) {
+    return null;
+  }
+  const values = [];
+  for (const item of expr.value) {
+    if (typeof item !== "string") {
+      return null;
+    }
+    values.push(item);
+  }
+  return values;
+}
+function readLiteralEntries(expr) {
+  if (expr.kind !== "lit" || !Array.isArray(expr.value)) {
+    return null;
+  }
+  const entries = [];
+  for (const item of expr.value) {
+    if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== "string") {
+      return null;
+    }
+    entries.push([item[0], item[1]]);
+  }
+  return entries;
+}
+function unionIgnoringUnknown(types) {
+  const filtered = types.filter((type) => type.kind !== "unknown");
+  return filtered.length === 0 ? unknownType() : unionOf(filtered);
+}
+function isNumericSegment(segment) {
+  return /^\d+$/.test(segment);
+}
+function warn(ctx, message) {
+  if (ctx.warnedMessages.has(message)) {
+    return;
+  }
+  ctx.warnedMessages.add(message);
+  ctx.diagnostics.push({
+    level: "warn",
+    plugin: ctx.pluginName,
+    message
+  });
+}
+
+// src/plugins/domain-plugin.ts
+var PLUGIN_NAME = "codegen-plugin-domain";
+function createDomainPlugin(options) {
+  return {
+    name: PLUGIN_NAME,
+    generate(ctx) {
+      const diagnostics = [];
+      const inference = createInferenceContext(ctx.schema, diagnostics, PLUGIN_NAME);
+      const interfaceName = options?.interfaceName ?? deriveInterfaceName(ctx) ?? "Domain";
+      const fileName = options?.fileName ?? deriveFileName(ctx.sourceId);
+      const stateFields = renderFieldBlock(
+        ctx.schema.state.fields,
+        { includeReservedState: options?.includeReservedState ?? false },
+        (_name, spec) => fieldSpecToDomainField(spec)
+      );
+      const computedFields = renderFieldBlock(
+        ctx.schema.computed.fields,
+        { includeReservedState: true },
+        (name) => ({
+          type: inferComputedType(name, inference),
+          optional: false
+        })
+      );
+      const actionNames = Object.keys(ctx.schema.actions).sort();
+      const actionLines = actionNames.map((name) => {
+        const action = ctx.schema.actions[name];
+        return `    ${name}: ${renderActionSignature(action.input)}`;
+      });
+      const sections = [
+        "export interface " + interfaceName + " {",
+        "  readonly state: {",
+        stateFields,
+        "  }",
+        "  readonly computed: {",
+        computedFields,
+        "  }",
+        "  readonly actions: {",
+        actionLines.join("\n"),
+        "  }",
+        "}"
+      ];
+      return {
+        patches: [{ op: "set", path: fileName, content: sections.join("\n") + "\n" }],
+        diagnostics
+      };
+    }
+  };
+}
+function renderFieldBlock(source, options, mapField) {
+  const names = Object.keys(source).filter((name) => options.includeReservedState || !name.startsWith("$")).sort();
+  if (names.length === 0) {
+    return "";
+  }
+  return names.map((name) => {
+    const field = mapField(name, source[name]);
+    const optional = field.optional ? "?" : "";
+    return `    ${name}${optional}: ${renderDomainType(field.type)}`;
+  }).join("\n");
+}
+function renderActionSignature(input) {
+  if (!input || typeof input !== "object" || !("type" in input)) {
+    return "() => void";
+  }
+  if (input.type !== "object" || !input.fields) {
+    return `(input: ${renderDomainType(fieldSpecToDomainType(input))}) => void`;
+  }
+  const names = Object.keys(input.fields);
+  if (names.length === 0) {
+    return "() => void";
+  }
+  const params = names.map((name) => {
+    const field = fieldSpecToDomainField(input.fields[name]);
+    const optional = field.optional ? "?" : "";
+    return `${name}${optional}: ${renderDomainType(field.type)}`;
+  });
+  return `(${params.join(", ")}) => void`;
+}
+function deriveInterfaceName(ctx) {
+  const metaName = ctx.schema.meta?.name?.trim();
+  if (metaName) {
+    return metaName;
+  }
+  const basename = basenameWithoutExtension(ctx.sourceId);
+  if (!basename) {
+    return null;
+  }
+  const candidate = pascalCase(basename);
+  return candidate.endsWith("Domain") ? candidate : `${candidate}Domain`;
+}
+function deriveFileName(sourceId) {
+  if (!sourceId) {
+    return "domain.ts";
+  }
+  const normalized = sourceId.replace(/\\/g, "/");
+  return `${normalized}.ts`;
+}
+function basenameWithoutExtension(sourceId) {
+  if (!sourceId) {
+    return null;
+  }
+  const normalized = sourceId.replace(/\\/g, "/");
+  const basename = normalized.split("/").pop() ?? "";
+  if (!basename) {
+    return null;
+  }
+  return basename.replace(/\.[^.]+$/, "");
+}
+function pascalCase(value) {
+  return value.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+}
+
 // src/plugins/ts-plugin.ts
-var PLUGIN_NAME = "codegen-plugin-ts";
+var PLUGIN_NAME2 = "codegen-plugin-ts";
 function createTsPlugin(options) {
   const typesFile = options?.typesFile ?? "types.ts";
   const actionsFile = options?.actionsFile ?? "actions.ts";
   return {
-    name: PLUGIN_NAME,
+    name: PLUGIN_NAME2,
     generate(ctx) {
       const diagnostics = [];
       const typeNames = [];
@@ -238,7 +997,7 @@ function createTsPlugin(options) {
       for (const actionName of sortedActionNames) {
         const spec = ctx.schema.actions[actionName];
         if (spec.input) {
-          const typeName = pascalCase(actionName) + "Input";
+          const typeName = pascalCase2(actionName) + "Input";
           actionDecls.push(renderActionInputType(typeName, spec, diagnostics));
         }
       }
@@ -283,7 +1042,7 @@ function mapTypeDefinition(def, diagnostics) {
     case "primitive":
       return mapPrimitive(def.type);
     case "literal":
-      return renderLiteral(def.value);
+      return renderLiteral2(def.value);
     case "array":
       return `${wrapComplex(mapTypeDefinition(def.element, diagnostics), def.element)}[]`;
     case "record":
@@ -306,7 +1065,7 @@ function mapTypeDefinition(def, diagnostics) {
     default: {
       diagnostics.push({
         level: "warn",
-        plugin: PLUGIN_NAME,
+        plugin: PLUGIN_NAME2,
         message: `Unknown TypeDefinition kind: "${def.kind}". Emitting "unknown".`
       });
       return "unknown";
@@ -327,7 +1086,7 @@ function mapPrimitive(type) {
       return "unknown";
   }
 }
-function renderLiteral(value) {
+function renderLiteral2(value) {
   if (typeof value === "string") {
     return JSON.stringify(value);
   }
@@ -355,7 +1114,7 @@ function mapFieldSpec(spec, diagnostics) {
 }
 function mapFieldType(type, spec, diagnostics) {
   if (typeof type === "object" && "enum" in type) {
-    return type.enum.map((v) => renderLiteral(v)).join(" | ");
+    return type.enum.map((v) => renderLiteral2(v)).join(" | ");
   }
   switch (type) {
     case "string":
@@ -380,7 +1139,7 @@ function mapFieldType(type, spec, diagnostics) {
       }
       diagnostics.push({
         level: "warn",
-        plugin: PLUGIN_NAME,
+        plugin: PLUGIN_NAME2,
         message: "Object field without fields spec, degrading to Record<string, unknown>"
       });
       return "Record<string, unknown>";
@@ -391,7 +1150,7 @@ function mapFieldType(type, spec, diagnostics) {
       }
       diagnostics.push({
         level: "warn",
-        plugin: PLUGIN_NAME,
+        plugin: PLUGIN_NAME2,
         message: "Array field without items spec, degrading to unknown[]"
       });
       return "unknown[]";
@@ -400,17 +1159,17 @@ function mapFieldType(type, spec, diagnostics) {
       return "unknown";
   }
 }
-function pascalCase(str) {
+function pascalCase2(str) {
   return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
 }
 
 // src/plugins/zod-plugin.ts
-var PLUGIN_NAME2 = "codegen-plugin-zod";
+var PLUGIN_NAME3 = "codegen-plugin-zod";
 var TS_PLUGIN_NAME = "codegen-plugin-ts";
 function createZodPlugin(options) {
   const schemasFile = options?.schemasFile ?? "base.ts";
   return {
-    name: PLUGIN_NAME2,
+    name: PLUGIN_NAME3,
     generate(ctx) {
       const diagnostics = [];
       const tsArtifacts = ctx.artifacts[TS_PLUGIN_NAME];
@@ -462,7 +1221,7 @@ function mapTypeDefinition2(def, allTypeNames, diagnostics) {
     default: {
       diagnostics.push({
         level: "warn",
-        plugin: PLUGIN_NAME2,
+        plugin: PLUGIN_NAME3,
         message: `Unknown TypeDefinition kind: "${def.kind}". Emitting "z.unknown()".`
       });
       return "z.unknown()";
@@ -497,7 +1256,7 @@ function handleRecord(def, allTypeNames, diagnostics) {
   if (def.key.kind !== "primitive" || def.key.type !== "string") {
     diagnostics.push({
       level: "warn",
-      plugin: PLUGIN_NAME2,
+      plugin: PLUGIN_NAME3,
       message: `Record key type is not string (got ${JSON.stringify(def.key)}). Degrading to z.record(z.string(), ...).`
     });
     return `z.record(z.string(), ${valueSchema})`;
@@ -534,6 +1293,7 @@ function handleUnion(types, allTypeNames, diagnostics) {
   return `z.union([${schemas.join(", ")}])`;
 }
 export {
+  createDomainPlugin,
   createTsPlugin,
   createZodPlugin,
   generate,