@saacms/core 0.1.0

package/dist/index-a3pnt8yz.js

@@ -0,0 +1,1494 @@
+import {
+  withMediaFields
+} from "./index-8g8ymd37.js";
+// src/codegen/to-openapi.ts
+import { JSONSchema, Schema, SchemaAST } from "effect";
+var DEFAULT_BASE_PATH = "/api/saacms/v1";
+var SECURITY = [
+  { cookieAuth: [] },
+  { bearerAuth: [] }
+];
+var PROBLEM_DETAILS_REF = {
+  $ref: "#/components/schemas/ProblemDetails"
+};
+var LINK_HEADER = {
+  description: "Web Linking per RFC 8288. Carries `self`, `next`, `prev`, `first`, `last`, `up` rels.",
+  schema: { type: "string" }
+};
+var ETAG_HEADER = {
+  description: "Strong validator per RFC 9110 §13. Use with `If-Match` on writes and `If-None-Match` on reads.",
+  schema: { type: "string" }
+};
+var LOCATION_HEADER = {
+  description: "URI of the newly created resource.",
+  schema: { type: "string", format: "uri-reference" }
+};
+var RETRY_AFTER_HEADER = {
+  description: "Per RFC 9110 §10.2.3 — number of seconds (or HTTP date) before the client should retry.",
+  schema: { type: "string" }
+};
+var idPathParam = {
+  name: "id",
+  in: "path",
+  required: true,
+  description: "Opaque record identifier.",
+  schema: { type: "string" }
+};
+var cursorParam = {
+  name: "cursor",
+  in: "query",
+  required: false,
+  description: "Opaque base64-encoded keyset cursor over the chosen sort. Per ADR 0018 §4 / Geewax §21.",
+  schema: { type: "string" }
+};
+var limitParam = {
+  name: "limit",
+  in: "query",
+  required: false,
+  description: "Max records to return. Default 20, max 100. Per ADR 0018 §4.",
+  schema: { type: "integer", minimum: 1, maximum: 100, default: 20 }
+};
+var sortParam = {
+  name: "sort",
+  in: "query",
+  required: false,
+  description: "Comma-separated sort fields, minus-prefix for descending (`-publishedAt,title`). Per ADR 0018 §6 / Massé §6.1 / AIP-132.",
+  schema: { type: "string" }
+};
+var includeCountParam = {
+  name: "include_count",
+  in: "query",
+  required: false,
+  description: "Opt-in to populate `_meta.totalCount`. Off by default (count() can be expensive).",
+  schema: { type: "boolean", default: false }
+};
+var ifMatchParam = {
+  name: "If-Match",
+  in: "header",
+  required: true,
+  description: "Strong ETag the client expects to match the current resource version. Mismatch → 412 (RFC 9110 §13.1.1).",
+  schema: { type: "string" }
+};
+var ifNoneMatchParam = {
+  name: "If-None-Match",
+  in: "header",
+  required: false,
+  description: "Conditional GET — server returns 304 Not Modified if the current ETag matches (RFC 9110 §13.1.2).",
+  schema: { type: "string" }
+};
+var idempotencyKeyParam = {
+  name: "Idempotency-Key",
+  in: "header",
+  required: false,
+  description: "Per draft-ietf-httpapi-idempotency-key-header. Advisory in v1 — the header is accepted but the server does NOT enforce a per-(user,key) response cache in v1. Duplicate-request deduplication is achieved via declarative collection `unique` constraints (ADR 0030); a duplicate insert against a `unique` field returns 409 Conflict.",
+  schema: { type: "string" }
+};
+var filterParam = {
+  name: "filter",
+  in: "query",
+  required: false,
+  description: "Field filters per ADR 0018 §5. Use bracket syntax: `filter[status]=published`, `filter[publishedAt.gte]=2026-01-01`, `filter[id]=a,b,c` (IN), `filter[status.ne]=draft` (negation). Operators per field type are documented per Collection.",
+  schema: {
+    type: "object",
+    additionalProperties: { type: "string" }
+  }
+};
+var DATE_SCHEMA_IDENTIFIERS = new Set([
+  "DateFromSelf",
+  "Date",
+  "DateTimeUtc",
+  "DateTimeUtcFromSelf",
+  "DateFromString",
+  "DateFromNumber"
+]);
+var DATE_TIME_JSON_SCHEMA = { type: "string", format: "date-time" };
+function astIdentifier(ast) {
+  const id = SchemaAST.getIdentifierAnnotation(ast);
+  return id._tag === "Some" ? id.value : undefined;
+}
+function isDateClassAst(ast) {
+  const id = astIdentifier(ast);
+  if (id != null && DATE_SCHEMA_IDENTIFIERS.has(id))
+    return true;
+  if (ast._tag === "Declaration") {
+    const schemaId = ast.annotations[SchemaAST.SchemaIdAnnotationId];
+    if (typeof schemaId === "symbol" && String(schemaId).includes("DateFromSelf")) {
+      return true;
+    }
+  }
+  return false;
+}
+function rewriteDateAst(ast) {
+  if (isDateClassAst(ast)) {
+    return SchemaAST.annotations(ast, {
+      [SchemaAST.JSONSchemaAnnotationId]: DATE_TIME_JSON_SCHEMA,
+      [SchemaAST.DescriptionAnnotationId]: undefined,
+      [SchemaAST.TitleAnnotationId]: undefined
+    });
+  }
+  switch (ast._tag) {
+    case "TypeLiteral": {
+      const propertySignatures = ast.propertySignatures.map((p) => new SchemaAST.PropertySignature(p.name, rewriteDateAst(p.type), p.isOptional, p.isReadonly, p.annotations));
+      const indexSignatures = ast.indexSignatures.map((s) => new SchemaAST.IndexSignature(s.parameter, rewriteDateAst(s.type), s.isReadonly));
+      return new SchemaAST.TypeLiteral(propertySignatures, indexSignatures, ast.annotations);
+    }
+    case "TupleType": {
+      const elements = ast.elements.map((e) => new SchemaAST.OptionalType(rewriteDateAst(e.type), e.isOptional, e.annotations));
+      const rest = ast.rest.map((r) => new SchemaAST.Type(rewriteDateAst(r.type), r.annotations));
+      return new SchemaAST.TupleType(elements, rest, ast.isReadonly, ast.annotations);
+    }
+    case "Union":
+      return SchemaAST.Union.make(ast.types.map(rewriteDateAst), ast.annotations);
+    case "Suspend":
+      return new SchemaAST.Suspend(() => rewriteDateAst(ast.f()), ast.annotations);
+    case "Refinement":
+      return new SchemaAST.Refinement(rewriteDateAst(ast.from), ast.filter, ast.annotations);
+    case "Transformation":
+      return new SchemaAST.Transformation(rewriteDateAst(ast.from), rewriteDateAst(ast.to), ast.transformation, ast.annotations);
+    default:
+      return ast;
+  }
+}
+function normalizeDateSchemas(schema) {
+  return Schema.make(rewriteDateAst(schema.ast));
+}
+function schemaToOpenApiSchema(schema) {
+  const normalized = normalizeDateSchemas(schema);
+  const base = JSONSchema.make(normalized, { target: "openApi3.1" });
+  const out = base;
+  const top = readSaacmsAnnotations(schema.ast);
+  return mergeAnnotationsOntoSchema(out, top, schema.ast);
+}
+function readSaacmsAnnotations(annotated) {
+  const a = annotated.annotations;
+  const out = {};
+  if (typeof a["saacmsLabel"] === "string")
+    out.saacmsLabel = a["saacmsLabel"];
+  if (typeof a["saacmsHelp"] === "string")
+    out.saacmsHelp = a["saacmsHelp"];
+  if (typeof a["saacmsFormat"] === "string")
+    out.saacmsFormat = a["saacmsFormat"];
+  return out;
+}
+function findSaacmsAnnotationsDeep(ast) {
+  let current = ast;
+  let acc = {};
+  for (let depth = 0;depth < 8 && current != null; depth++) {
+    const here = readSaacmsAnnotations(current);
+    acc = {
+      saacmsLabel: acc.saacmsLabel ?? here.saacmsLabel,
+      saacmsHelp: acc.saacmsHelp ?? here.saacmsHelp,
+      saacmsFormat: acc.saacmsFormat ?? here.saacmsFormat
+    };
+    if (acc.saacmsLabel != null && acc.saacmsHelp != null && acc.saacmsFormat != null) {
+      break;
+    }
+    const next = current.from;
+    if (next == null || next === current)
+      break;
+    current = next;
+  }
+  return acc;
+}
+function mergeAnnotationsOntoSchema(schema, ann, ast) {
+  let next = { ...schema };
+  if (ann.saacmsLabel != null) {
+    const help = ann.saacmsHelp != null ? ` (${ann.saacmsHelp})` : "";
+    next = { ...next, description: `${ann.saacmsLabel}${help}` };
+  } else if (ann.saacmsHelp != null && next.description == null) {
+    next = { ...next, description: ann.saacmsHelp };
+  }
+  if (ann.saacmsFormat != null) {
+    next = { ...next, format: ann.saacmsFormat };
+  }
+  if (SchemaAST.isTypeLiteral(ast) && next.properties != null) {
+    const properties = { ...next.properties };
+    for (const prop of ast.propertySignatures) {
+      const name = String(prop.name);
+      const child = properties[name];
+      if (child == null)
+        continue;
+      const sigAnn = readSaacmsAnnotations(prop);
+      const typeAnn = findSaacmsAnnotationsDeep(prop.type);
+      const merged = {
+        saacmsLabel: sigAnn.saacmsLabel ?? typeAnn.saacmsLabel,
+        saacmsHelp: sigAnn.saacmsHelp ?? typeAnn.saacmsHelp,
+        saacmsFormat: sigAnn.saacmsFormat ?? typeAnn.saacmsFormat
+      };
+      properties[name] = mergeAnnotationsOntoSchema(child, merged, prop.type);
+    }
+    next = { ...next, properties };
+  }
+  return next;
+}
+function collectionToOpenApiPaths(coll, opts = {}) {
+  coll = withMediaFields(coll);
+  const basePath = opts.basePath ?? DEFAULT_BASE_PATH;
+  const slug = String(coll.slug);
+  const tag = slug;
+  const recordName = pascalCase(slug);
+  const recordSchema = schemaToOpenApiSchema(coll.schema);
+  const recordRef = {
+    $ref: `#/components/schemas/${recordName}`
+  };
+  const collectionPath = `${basePath}/${slug}`;
+  const recordPath = `${collectionPath}/{id}`;
+  const envelopeSingle = singletonEnvelopeSchema(recordRef);
+  const envelopeList = listEnvelopeSchema(recordRef);
+  const paths = {
+    [collectionPath]: {
+      get: listOperation({ tag, slug, envelope: envelopeList }),
+      post: createOperation({ tag, slug, recordName, envelope: envelopeSingle, recordPath })
+    },
+    [recordPath]: {
+      get: getOneOperation({ tag, slug, envelope: envelopeSingle }),
+      put: replaceOperation({ tag, slug, recordName, envelope: envelopeSingle }),
+      patch: patchOperation({ tag, slug, recordName, envelope: envelopeSingle }),
+      delete: deleteOperation({ tag, slug })
+    }
+  };
+  return {
+    paths,
+    components: {
+      schemas: {
+        [recordName]: recordSchema,
+        ProblemDetails: PROBLEM_DETAILS_SCHEMA
+      }
+    }
+  };
+}
+function listOperation(args) {
+  return {
+    tags: [args.tag],
+    summary: `List ${args.slug}`,
+    description: `Cursor-paginated list of ${args.slug}. Per ADR 0018 §4 (cursor pagination), §5 (filter brackets), §6 (sort). Returns a HAL-light envelope per ADR 0018 §2.`,
+    operationId: `list${pascalCase(args.slug)}`,
+    parameters: [cursorParam, limitParam, sortParam, includeCountParam, filterParam],
+    responses: {
+      "200": {
+        description: "List page.",
+        headers: { Link: LINK_HEADER },
+        content: { "application/json": { schema: args.envelope } }
+      },
+      ...standardErrorResponses({ includePreconditions: false, includeUnprocessable: false })
+    },
+    security: [...SECURITY]
+  };
+}
+function createOperation(args) {
+  return {
+    tags: [args.tag],
+    summary: `Create a ${args.slug} record`,
+    description: `Creates a new ${args.slug}. Per RFC 9110 §15.3.2 returns 201 Created with \`Location\` header. When the collection declares a \`unique\` constraint, a duplicate insert returns 409 Conflict (ADR 0030). The \`Idempotency-Key\` header is accepted as advisory in v1 (not server-enforced).`,
+    operationId: `create${args.recordName}`,
+    parameters: [idempotencyKeyParam],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: { $ref: `#/components/schemas/${args.recordName}` }
+        }
+      }
+    },
+    responses: {
+      "201": {
+        description: "Created.",
+        headers: {
+          Location: LOCATION_HEADER,
+          ETag: ETAG_HEADER
+        },
+        content: { "application/json": { schema: args.envelope } }
+      },
+      ...standardErrorResponses({ includePreconditions: false, includeUnprocessable: true })
+    },
+    security: [...SECURITY]
+  };
+}
+function getOneOperation(args) {
+  return {
+    tags: [args.tag],
+    summary: `Get one ${args.slug}`,
+    description: `Returns a single ${args.slug} record. Per ADR 0018 §7, response includes a strong \`ETag\` header; clients may use \`If-None-Match\` for conditional GET (304 Not Modified).`,
+    operationId: `get${pascalCase(args.slug)}ById`,
+    parameters: [idPathParam, ifNoneMatchParam],
+    responses: {
+      "200": {
+        description: "OK.",
+        headers: {
+          ETag: ETAG_HEADER,
+          Link: LINK_HEADER
+        },
+        content: { "application/json": { schema: args.envelope } }
+      },
+      "304": { description: "Not Modified — `If-None-Match` matched current ETag." },
+      ...standardErrorResponses({ includePreconditions: false, includeUnprocessable: false })
+    },
+    security: [...SECURITY]
+  };
+}
+function replaceOperation(args) {
+  return {
+    tags: [args.tag],
+    summary: `Replace a ${args.slug} record`,
+    description: `Full replacement (PUT) per RFC 9110 §15.3.4. Requires \`If-Match\` per ADR 0018 §7; missing precondition returns 428.`,
+    operationId: `replace${args.recordName}`,
+    parameters: [idPathParam, ifMatchParam, idempotencyKeyParam],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: { $ref: `#/components/schemas/${args.recordName}` }
+        }
+      }
+    },
+    responses: {
+      "200": {
+        description: "Replaced.",
+        headers: { ETag: ETAG_HEADER },
+        content: { "application/json": { schema: args.envelope } }
+      },
+      ...standardErrorResponses({ includePreconditions: true, includeUnprocessable: true })
+    },
+    security: [...SECURITY]
+  };
+}
+function patchOperation(args) {
+  return {
+    tags: [args.tag],
+    summary: `Patch a ${args.slug} record`,
+    description: `Partial update (PATCH) per RFC 5789 / RFC 9110. Body is a partial of the record schema. Requires \`If-Match\` per ADR 0018 §7.`,
+    operationId: `patch${args.recordName}`,
+    parameters: [idPathParam, ifMatchParam, idempotencyKeyParam],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            allOf: [{ $ref: `#/components/schemas/${args.recordName}` }]
+          }
+        }
+      }
+    },
+    responses: {
+      "200": {
+        description: "Patched.",
+        headers: { ETag: ETAG_HEADER },
+        content: { "application/json": { schema: args.envelope } }
+      },
+      ...standardErrorResponses({ includePreconditions: true, includeUnprocessable: true })
+    },
+    security: [...SECURITY]
+  };
+}
+function deleteOperation(args) {
+  return {
+    tags: [args.tag],
+    summary: `Delete a ${args.slug} record`,
+    description: `Deletes a record. Requires \`If-Match\` per ADR 0018 §7. Returns 204 No Content on success.`,
+    operationId: `delete${pascalCase(args.slug)}`,
+    parameters: [idPathParam, ifMatchParam, idempotencyKeyParam],
+    responses: {
+      "204": { description: "Deleted." },
+      ...standardErrorResponses({ includePreconditions: true, includeUnprocessable: false })
+    },
+    security: [...SECURITY]
+  };
+}
+function problemResponse(description) {
+  return {
+    description,
+    content: {
+      "application/problem+json": { schema: PROBLEM_DETAILS_REF }
+    }
+  };
+}
+function standardErrorResponses(opts) {
+  const base = {
+    "400": problemResponse("Bad Request — malformed request (RFC 9110 §15.5.1)."),
+    "401": problemResponse("Unauthorized — missing or invalid auth (RFC 9110 §15.5.2)."),
+    "403": problemResponse("Forbidden — authenticated but not allowed (RFC 9110 §15.5.4)."),
+    "404": problemResponse("Not Found (RFC 9110 §15.5.5). Note: hidden resources also return 404 by default per OWASP API Security Top 10 #1."),
+    "409": problemResponse("Conflict — state conflict, duplicate unique field, or idempotency-key reuse with different payload (RFC 9110 §15.5.10)."),
+    "429": {
+      description: "Too Many Requests — rate-limited (RFC 6585 §4).",
+      headers: { "Retry-After": RETRY_AFTER_HEADER },
+      content: {
+        "application/problem+json": { schema: PROBLEM_DETAILS_REF }
+      }
+    }
+  };
+  if (opts.includeUnprocessable) {
+    base["422"] = problemResponse("Unprocessable Content — body parsed but failed business validation (RFC 9110 §15.5.21).");
+  }
+  if (opts.includePreconditions) {
+    base["412"] = problemResponse("Precondition Failed — `If-Match` ETag did not match current state (RFC 9110 §15.5.13).");
+    base["428"] = problemResponse("Precondition Required — unsafe write without `If-Match` (RFC 6585 §3).");
+  }
+  return base;
+}
+var linkObjectSchema = {
+  type: "object",
+  required: ["href"],
+  properties: {
+    href: { type: "string", format: "uri-reference" }
+  },
+  additionalProperties: true
+};
+var linksMapSchema = {
+  type: "object",
+  description: "RFC 8288-style link map. Keys are link-relation names (`self`, `next`, `prev`, `up`, `first`, `last`, custom rels).",
+  additionalProperties: linkObjectSchema
+};
+var actionSchema = {
+  type: "object",
+  required: ["rel", "method", "href"],
+  properties: {
+    rel: { type: "string" },
+    method: { type: "string" },
+    href: { type: "string", format: "uri-reference" }
+  },
+  additionalProperties: true
+};
+function singletonEnvelopeSchema(dataRef) {
+  return {
+    type: "object",
+    required: ["data"],
+    properties: {
+      data: dataRef,
+      _links: linksMapSchema,
+      _actions: { type: "array", items: actionSchema },
+      _meta: { type: "object", additionalProperties: true }
+    }
+  };
+}
+function listEnvelopeSchema(itemRef) {
+  return {
+    type: "object",
+    required: ["data"],
+    properties: {
+      data: { type: "array", items: itemRef },
+      _links: linksMapSchema,
+      _meta: {
+        type: "object",
+        properties: {
+          hasMore: { type: "boolean" },
+          totalCount: { type: "integer", description: "Present only when `?include_count=true`." }
+        },
+        additionalProperties: true
+      }
+    }
+  };
+}
+var PROBLEM_DETAILS_SCHEMA = {
+  type: "object",
+  description: "RFC 9457 Problem Details document. saacms returns this for every 4xx/5xx response. Per ADR 0018 §3.",
+  required: ["type", "title", "status"],
+  properties: {
+    type: {
+      type: "string",
+      format: "uri",
+      description: "URI identifying the error class. saacms hosts the registry at saacms.dev/errors/<class>."
+    },
+    title: { type: "string", description: "Short, human-readable summary." },
+    status: { type: "integer", description: "Mirror of the HTTP status code (RFC 9457 §3.1.4)." },
+    detail: { type: "string", description: "Human-readable explanation specific to this occurrence." },
+    instance: { type: "string", description: "URI identifying the specific occurrence." },
+    errors: {
+      type: "array",
+      description: "saacms extension (per RFC 9457 §3.2, extensions are explicitly allowed). Per-field validation details.",
+      items: {
+        type: "object",
+        required: ["path", "code", "message"],
+        properties: {
+          path: { type: "string" },
+          code: { type: "string" },
+          message: { type: "string" }
+        }
+      }
+    }
+  },
+  additionalProperties: true
+};
+function pascalCase(input) {
+  return input.split(/[-_\s]+/).filter((s) => s.length > 0).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+// src/codegen/to-drizzle.ts
+import { SchemaAST as AST, Option } from "effect";
+import {
+  sqliteTable,
+  text,
+  integer,
+  real
+} from "drizzle-orm/sqlite-core";
+function makePlaceholderRegistry() {
+  const cache = new Map;
+  return {
+    getIdColumn(slug) {
+      let placeholder = cache.get(slug);
+      if (placeholder === undefined) {
+        placeholder = sqliteTable(slug, {
+          id: text("id").primaryKey()
+        });
+        cache.set(slug, placeholder);
+      }
+      return placeholder.id;
+    }
+  };
+}
+function readSaacmsAnnotation(ast, key) {
+  const v = ast.annotations[key];
+  return v === undefined ? undefined : v;
+}
+function resolveFieldType(signature) {
+  let t = signature.type;
+  let isNullable = signature.isOptional;
+  if (AST.isUnion(t)) {
+    const nonNullish = t.types.filter((m) => !AST.isUndefinedKeyword(m) && !isNullKeyword(m));
+    if (nonNullish.length !== t.types.length) {
+      isNullable = true;
+    }
+    if (nonNullish.length === 1) {
+      t = nonNullish[0];
+    }
+  }
+  while (AST.isRefinement(t)) {
+    t = t.from;
+  }
+  return { inner: t, isNullable };
+}
+function isNullKeyword(ast) {
+  return AST.isLiteral(ast) && ast.literal === null;
+}
+function buildColumn(name, resolved, registry) {
+  const { inner, isNullable } = resolved;
+  const refSlug = readSaacmsAnnotation(inner, "saacmsRef");
+  const isInt = readSaacmsAnnotation(inner, "saacmsInt") === true;
+  const length = readSaacmsAnnotation(inner, "saacmsLength");
+  const onDelete = readSaacmsAnnotation(inner, "saacmsRefOnDelete") ?? "cascade";
+  let col;
+  if (isDateLikeAst(inner)) {
+    col = integer(name, { mode: "timestamp" });
+  } else if (AST.isStringKeyword(inner)) {
+    col = length !== undefined ? text(name, { length }) : text(name);
+  } else if (AST.isNumberKeyword(inner)) {
+    col = isInt ? integer(name) : real(name);
+  } else if (AST.isBooleanKeyword(inner)) {
+    col = integer(name, { mode: "boolean" });
+  } else if (AST.isTupleType(inner)) {
+    col = text(name, { mode: "json" });
+  } else if (AST.isTypeLiteral(inner)) {
+    col = text(name, { mode: "json" });
+  } else {
+    col = text(name);
+  }
+  if (refSlug !== undefined && AST.isStringKeyword(inner)) {
+    const refsCol = col;
+    col = refsCol.references(() => registry.getIdColumn(refSlug), { onDelete });
+  }
+  if (!isNullable) {
+    const notNullable = col;
+    col = notNullable.notNull();
+  }
+  return col;
+}
+function isDateLikeAst(ast) {
+  const id = Option.getOrUndefined(AST.getIdentifierAnnotation(ast));
+  if (id === "DateFromSelf" || id === "Date" || id === "ValidDateFromSelf") {
+    return true;
+  }
+  if (id === "DateFromString" || id === "DateFromNumber") {
+    return true;
+  }
+  return false;
+}
+function schemaToDrizzle(slug, schema) {
+  const root = schema.ast;
+  if (!AST.isTypeLiteral(root)) {
+    throw new Error(`schemaToDrizzle: root schema for "${slug}" must be a Struct (TypeLiteral); got ${root._tag}`);
+  }
+  const registry = makePlaceholderRegistry();
+  const columns = {};
+  for (const ps of root.propertySignatures) {
+    const name = String(ps.name);
+    if (name === "id" || name === "createdAt" || name === "updatedAt") {
+      continue;
+    }
+    const resolved = resolveFieldType(ps);
+    columns[name] = buildColumn(name, resolved, registry);
+  }
+  columns["id"] = text("id").primaryKey();
+  columns["createdAt"] = integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date);
+  columns["updatedAt"] = integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date);
+  return sqliteTable(slug, columns);
+}
+// src/codegen/to-d1-migration.ts
+import { SchemaAST as AST2, Option as Option2 } from "effect";
+function readSaacmsAnnotation2(ast, key) {
+  const v = ast.annotations[key];
+  return v === undefined ? undefined : v;
+}
+function resolveFieldType2(signature) {
+  let t = signature.type;
+  let isNullable = signature.isOptional;
+  if (AST2.isUnion(t)) {
+    const nonNullish = t.types.filter((m) => !AST2.isUndefinedKeyword(m) && !isNullKeyword2(m));
+    if (nonNullish.length !== t.types.length) {
+      isNullable = true;
+    }
+    if (nonNullish.length === 1) {
+      t = nonNullish[0];
+    }
+  }
+  while (AST2.isRefinement(t)) {
+    t = t.from;
+  }
+  return { inner: t, isNullable };
+}
+function isNullKeyword2(ast) {
+  return AST2.isLiteral(ast) && ast.literal === null;
+}
+function isDateLikeAst2(ast) {
+  const id = Option2.getOrUndefined(AST2.getIdentifierAnnotation(ast));
+  if (id === "DateFromSelf" || id === "Date" || id === "ValidDateFromSelf") {
+    return true;
+  }
+  if (id === "DateFromString" || id === "DateFromNumber") {
+    return true;
+  }
+  return false;
+}
+function tryGetStringLiteralUnion(ast) {
+  if (!AST2.isUnion(ast))
+    return;
+  const literals = [];
+  for (const m of ast.types) {
+    if (AST2.isUndefinedKeyword(m) || isNullKeyword2(m))
+      continue;
+    if (AST2.isLiteral(m) && typeof m.literal === "string") {
+      literals.push(m.literal);
+    } else {
+      return;
+    }
+  }
+  return literals.length > 0 ? literals : undefined;
+}
+function camelToSnakeCase(name) {
+  return name.replace(/[A-Z]/g, (m) => `_${m.toLowerCase()}`);
+}
+function quoteIdent(name) {
+  return `"${name}"`;
+}
+function slugToTableName(slug) {
+  let name = String(slug).replace(/[^A-Za-z0-9_]/g, "_");
+  if (name.length === 0 || /^[0-9]/.test(name)) {
+    name = `_${name}`;
+  }
+  if (name.length > 64) {
+    name = name.slice(0, 64);
+  }
+  return name;
+}
+function assertNoTableNameCollisions(colls) {
+  const seen = new Map;
+  for (const c of colls) {
+    const slug = String(c.slug);
+    const table = slugToTableName(slug);
+    const prior = seen.get(table);
+    if (prior !== undefined && prior !== slug) {
+      throw new Error(`assertNoTableNameCollisions: collection slugs "${prior}" and "${slug}" ` + `both project to the physical table name "${table}". External slugs are ` + `the data contract and cannot be changed; rename one collection's slug ` + `so the projected table identifiers are distinct.`);
+    }
+    if (prior === undefined)
+      seen.set(table, slug);
+  }
+}
+function escapeSqlString(s) {
+  return s.replace(/'/g, "''");
+}
+function buildColumnSql(collSlug, jsName, signature) {
+  const { inner, isNullable } = resolveFieldType2(signature);
+  const sqlName = camelToSnakeCase(jsName);
+  const refSlug = readSaacmsAnnotation2(inner, "saacmsRef");
+  const isInt = readSaacmsAnnotation2(inner, "saacmsInt") === true;
+  const onDelete = readSaacmsAnnotation2(inner, "saacmsRefOnDelete") ?? "cascade";
+  let sqlType;
+  let checkClause;
+  const literalUnion = tryGetStringLiteralUnion(inner);
+  if (literalUnion !== undefined) {
+    sqlType = "TEXT";
+    const values = literalUnion.map((v) => `'${escapeSqlString(v)}'`).join(", ");
+    checkClause = `CHECK (${quoteIdent(sqlName)} IN (${values}))`;
+  } else if (isDateLikeAst2(inner)) {
+    sqlType = "TEXT";
+  } else if (AST2.isStringKeyword(inner)) {
+    sqlType = "TEXT";
+  } else if (AST2.isNumberKeyword(inner)) {
+    sqlType = isInt ? "INTEGER" : "REAL";
+  } else if (AST2.isBooleanKeyword(inner)) {
+    sqlType = "INTEGER";
+  } else if (AST2.isTupleType(inner)) {
+    sqlType = "TEXT";
+  } else if (AST2.isTypeLiteral(inner)) {
+    sqlType = "TEXT";
+  } else {
+    sqlType = "TEXT";
+  }
+  const parts = [quoteIdent(sqlName), sqlType];
+  if (!isNullable) {
+    parts.push("NOT NULL");
+  }
+  if (refSlug !== undefined) {
+    if (onDelete === "set null" && !isNullable) {
+      throw new Error(`schemaToD1Migration: field "${jsName}" on collection "${collSlug}" ` + `has saacmsRefOnDelete: "set null" but the column is NOT NULL — ` + `set null requires the column to be nullable.`);
+    }
+    parts.push(`REFERENCES ${quoteIdent(slugToTableName(refSlug))}("id") ON DELETE ${onDelete.toUpperCase()}`);
+  }
+  if (checkClause !== undefined) {
+    parts.push(checkClause);
+  }
+  return parts.join(" ");
+}
+function schemaToD1Migration(coll) {
+  coll = withMediaFields(coll);
+  const root = coll.schema.ast;
+  if (!AST2.isTypeLiteral(root)) {
+    throw new Error(`schemaToD1Migration: root schema for "${coll.slug}" must be a Struct (TypeLiteral); got ${root._tag}`);
+  }
+  const collSlug = String(coll.slug);
+  const knownFields = new Set(["id", "createdAt", "updatedAt"]);
+  for (const ps of root.propertySignatures) {
+    knownFields.add(String(ps.name));
+  }
+  const lines = [];
+  lines.push(`${quoteIdent("id")} TEXT PRIMARY KEY NOT NULL`);
+  for (const ps of root.propertySignatures) {
+    const name = String(ps.name);
+    if (name === "id" || name === "createdAt" || name === "updatedAt")
+      continue;
+    lines.push(buildColumnSql(collSlug, name, ps));
+  }
+  lines.push(`${quoteIdent("created_at")} TEXT NOT NULL DEFAULT (datetime('now'))`);
+  lines.push(`${quoteIdent("updated_at")} TEXT NOT NULL DEFAULT (datetime('now'))`);
+  if (coll.unique != null && coll.unique.length > 0) {
+    for (const group of coll.unique) {
+      if (group.length === 0)
+        continue;
+      const snakeCols = [];
+      for (const camelName of group) {
+        if (!knownFields.has(camelName)) {
+          throw new Error(`schemaToD1Migration: unique group references unknown field "${camelName}" ` + `on collection "${collSlug}". Known fields: ${[...knownFields].sort().join(", ")}.`);
+        }
+        snakeCols.push(quoteIdent(camelToSnakeCase(camelName)));
+      }
+      lines.push(`UNIQUE(${snakeCols.join(", ")})`);
+    }
+  }
+  const body = lines.map((l) => `  ${l}`).join(`,
+`);
+  return `CREATE TABLE IF NOT EXISTS ${quoteIdent(slugToTableName(collSlug))} (
+${body}
+);`;
+}
+function schemaToD1Migrations(colls) {
+  assertNoTableNameCollisions(colls);
+  return colls.map((c) => schemaToD1Migration(c)).join(`
+
+`);
+}
+// src/codegen/content-migration.ts
+import { SchemaAST as AST3 } from "effect";
+function isNullKeyword3(ast) {
+  return AST3.isLiteral(ast) && ast.literal === null;
+}
+function resolveFieldType3(sig) {
+  let t = sig.type;
+  let optional = sig.isOptional;
+  if (AST3.isUnion(t)) {
+    const nonNullish = t.types.filter((m) => !AST3.isUndefinedKeyword(m) && !isNullKeyword3(m));
+    if (nonNullish.length !== t.types.length)
+      optional = true;
+    if (nonNullish.length === 1)
+      t = nonNullish[0];
+  }
+  while (AST3.isRefinement(t))
+    t = t.from;
+  return { inner: t, optional };
+}
+function literalUnionValues(ast) {
+  if (!AST3.isUnion(ast)) {
+    if (AST3.isLiteral(ast))
+      return [String(ast.literal)];
+    return;
+  }
+  const out = [];
+  for (const m of ast.types) {
+    if (AST3.isUndefinedKeyword(m) || isNullKeyword3(m))
+      continue;
+    if (AST3.isLiteral(m))
+      out.push(String(m.literal));
+    else
+      return;
+  }
+  return out.length > 0 ? out : undefined;
+}
+function projectType(ast) {
+  const lits = literalUnionValues(ast);
+  if (lits !== undefined)
+    return `literal:${[...lits].sort().join("|")}`;
+  if (AST3.isStringKeyword(ast))
+    return "string";
+  if (AST3.isNumberKeyword(ast))
+    return "number";
+  if (AST3.isBooleanKeyword(ast))
+    return "boolean";
+  if (AST3.isTupleType(ast))
+    return "array";
+  if (AST3.isTypeLiteral(ast))
+    return "object";
+  return "unknown";
+}
+function fingerprintBlockSchema(block) {
+  const root = block.schema.ast;
+  if (!AST3.isTypeLiteral(root)) {
+    throw new Error(`fingerprintBlockSchema: root schema for Block "${block.slug}" must be a Struct (TypeLiteral); got ${root._tag}`);
+  }
+  const fields = root.propertySignatures.map((ps) => {
+    const { inner, optional } = resolveFieldType3(ps);
+    return { name: String(ps.name), type: projectType(inner), optional };
+  });
+  fields.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  return { fields };
+}
+function fingerprintToString(fp) {
+  return JSON.stringify(fp.fields);
+}
+function diffBlockSchemas(prev, next) {
+  const prevByName = new Map(prev.fields.map((f) => [f.name, f]));
+  const nextByName = new Map(next.fields.map((f) => [f.name, f]));
+  const retyped = [];
+  for (const f of next.fields) {
+    const p = prevByName.get(f.name);
+    if (p !== undefined && p.type !== f.type) {
+      retyped.push({ name: f.name, fromType: p.type, toType: f.type });
+    }
+  }
+  const removedNames = prev.fields.filter((f) => !nextByName.has(f.name)).map((f) => f.name);
+  const addedFields = next.fields.filter((f) => !prevByName.has(f.name));
+  const renamed = [];
+  const consumedAdds = new Set;
+  const consumedRemoves = new Set;
+  for (const rm of removedNames) {
+    const rmShape = prevByName.get(rm);
+    const match = addedFields.find((a) => !consumedAdds.has(a.name) && a.type === rmShape.type);
+    if (match !== undefined) {
+      renamed.push({ from: rm, to: match.name, type: match.type });
+      consumedAdds.add(match.name);
+      consumedRemoves.add(rm);
+    }
+  }
+  const added = addedFields.filter((f) => !consumedAdds.has(f.name)).map((f) => ({ name: f.name, type: f.type, optional: f.optional }));
+  const removed = removedNames.filter((n) => !consumedRemoves.has(n)).map((n) => ({ name: n }));
+  const changed = added.length > 0 || removed.length > 0 || renamed.length > 0 || retyped.length > 0;
+  return { added, removed, renamed, retyped, changed };
+}
+function defaultLiteralFor(type) {
+  if (type === "string")
+    return `""`;
+  if (type === "number")
+    return `0`;
+  if (type === "boolean")
+    return `false`;
+  if (type === "array")
+    return `[]`;
+  if (type === "object")
+    return `{}`;
+  if (type.startsWith("literal:")) {
+    const first = type.slice("literal:".length).split("|")[0] ?? "";
+    return JSON.stringify(first);
+  }
+  return `null`;
+}
+function jsKey(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
+}
+function contentMigrationModuleSource(blockSlug, fromVersion, toVersion, diff) {
+  const slugLit = JSON.stringify(blockSlug);
+  const ops = [];
+  for (const r of diff.renamed) {
+    ops.push(`  // renamed: ${r.from} -> ${r.to} (type ${r.type}) — copy then drop
+` + `  if (${JSON.stringify(r.from)} in props) {
+` + `    props${jsKey(r.to)} = props${jsKey(r.from)}
+` + `    delete props${jsKey(r.from)}
+` + `  }`);
+  }
+  for (const a of diff.added) {
+    ops.push(`  // added: ${a.name} (type ${a.type}${a.optional ? ", optional" : ""}) — backfill default
+` + `  if (!(${JSON.stringify(a.name)} in props)) {
+` + `    props${jsKey(a.name)} = ${defaultLiteralFor(a.type)}
+` + `  }`);
+  }
+  for (const rm of diff.removed) {
+    ops.push(`  // removed: ${rm.name} — drop
+` + `  delete props${jsKey(rm.name)}`);
+  }
+  for (const rt of diff.retyped) {
+    ops.push(`  // RETYPED: ${rt.name} ${rt.fromType} -> ${rt.toType}
+` + `  // TODO(dev): a type change cannot be migrated automatically — convert
+` + `  //   props${jsKey(rt.name)} from ${rt.fromType} to ${rt.toType} here, then
+` + `  //   delete this TODO. Left as a no-op so the migration is reviewable.`);
+  }
+  const opsBody = ops.length > 0 ? ops.join(`
+
+`) : "  // (no structural change)";
+  return `/**
+ * AUTO-GENERATED content migration (saacms migrate generate) per ADR 0012.
+ *
+ * Block ${slugLit}: v${fromVersion} -> v${toVersion}.
+ *
+ * Review this transform before committing. It is deterministic and runs over
+ * all stored Page JSON (Git files in dev, DB-stored Pages in prod). Forward-
+ * only: rollback is git-revert + re-run (ADR 0012 "Deferred to v2").
+ *
+ * ACTION REQUIRED: bump \`version: ${toVersion}\` on the \`defineBlock({...})\`
+ * for ${slugLit} in your Block source. saacms does not edit your authored
+ * structure source — only stored instances (CONTEXT.md "Schema is the single
+ * source of truth; projections are mechanical").
+ */
+
+export const meta = {
+  block: ${slugLit},
+  fromVersion: ${fromVersion},
+  toVersion: ${toVersion},
+} as const
+
+const BLOCK_TYPE = ${slugLit}
+
+type Json = unknown
+interface BlockNode {
+  type?: unknown
+  props?: Record<string, unknown>
+  [key: string]: unknown
+}
+
+function isRecord(v: Json): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v)
+}
+
+/** Apply the v${fromVersion}->v${toVersion} field changes to one matching Block node's props. */
+function applyToBlock(node: BlockNode): BlockNode {
+  const props: Record<string, unknown> = { ...(node.props ?? {}) }
+
+${opsBody}
+
+  return { ...node, props }
+}
+
+/** Deep-walk any Page JSON value; transform every ${slugLit} Block instance. */
+function walk(value: Json): Json {
+  if (Array.isArray(value)) return value.map(walk)
+  if (isRecord(value)) {
+    let node: Record<string, unknown> = value
+    if (typeof node["type"] === "string" && node["type"] === BLOCK_TYPE) {
+      node = applyToBlock(node as BlockNode) as Record<string, unknown>
+    }
+    const out: Record<string, unknown> = {}
+    for (const k of Object.keys(node)) out[k] = walk(node[k])
+    return out
+  }
+  return value
+}
+
+/**
+ * Transform stored Page JSON from Block ${slugLit}@v${fromVersion} to @v${toVersion}.
+ * Pure: returns a new value; never mutates the input.
+ */
+export function up(pageJson: unknown): unknown {
+  return walk(pageJson)
+}
+
+/** Forward-only: v1 has no rollback machinery (ADR 0012 "Deferred to v2"). */
+export function down(_pageJson: unknown): never {
+  throw new Error(
+    "content migration ${blockSlug} v${toVersion}->v${fromVersion}: down() is not implemented (forward-only per ADR 0012; roll back via git-revert + re-run)",
+  )
+}
+`;
+}
+function detectPendingContentMigrations(input) {
+  const pending = [];
+  for (const block of input.blocks) {
+    const slug = String(block.slug);
+    const entry = input.snapshot[slug];
+    if (entry === undefined)
+      continue;
+    const currentFp = fingerprintToString(fingerprintBlockSchema(block));
+    const fingerprintDrifted = currentFp !== entry.fingerprint;
+    const expectedFile = `${slug}@v${entry.version}`;
+    const notApplied = input.appliedMigrations !== undefined && !input.appliedMigrations.some((f) => f.includes(slug));
+    if (!fingerprintDrifted && !notApplied)
+      continue;
+    const fromVersion = entry.version;
+    const toVersion = fingerprintDrifted ? entry.version + 1 : entry.version;
+    const reason = fingerprintDrifted ? `Page Blocks may be on \`${slug}@v${fromVersion}\`; current schema is ` + `\`${slug}@v${toVersion}\`; run \`saacms migrate generate\` then apply ` + `\`saacms/migrations/content/NNNN_*.ts\`` : `content migration \`${expectedFile}\` was generated for \`${slug}\` ` + `but has not been applied; run \`saacms migrate run\``;
+    pending.push({ slug, fromVersion, toVersion, reason });
+  }
+  return { pending, clean: pending.length === 0 };
+}
+// src/codegen/to-puck-fields.ts
+import { SchemaAST as AST4 } from "effect";
+function readSaacmsAnnotation3(ast, key) {
+  const v = ast.annotations[key];
+  return v === undefined ? undefined : v;
+}
+function isNullKeyword4(ast) {
+  return AST4.isLiteral(ast) && ast.literal === null;
+}
+function peel(ast) {
+  let t = ast;
+  if (AST4.isUnion(t)) {
+    const nonNullish = t.types.filter((m) => !AST4.isUndefinedKeyword(m) && !isNullKeyword4(m));
+    if (nonNullish.length === 1 && nonNullish.length !== t.types.length) {
+      t = nonNullish[0];
+    }
+  }
+  while (AST4.isRefinement(t)) {
+    t = t.from;
+  }
+  return t;
+}
+function tryGetStringLiteralUnion2(ast) {
+  if (!AST4.isUnion(ast))
+    return;
+  const out = [];
+  for (const m of ast.types) {
+    if (AST4.isUndefinedKeyword(m) || isNullKeyword4(m))
+      continue;
+    if (AST4.isLiteral(m) && typeof m.literal === "string") {
+      out.push(m.literal);
+    } else {
+      return;
+    }
+  }
+  return out.length > 0 ? out : undefined;
+}
+function defaultLabel(jsName) {
+  if (jsName.length === 0)
+    return jsName;
+  const spaced = jsName.replace(/([A-Z])/g, " $1").trim();
+  return spaced.split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function literalToOption(value) {
+  return {
+    label: value.charAt(0).toUpperCase() + value.slice(1),
+    value
+  };
+}
+function astToPuckField(ast, jsName) {
+  const inner = peel(ast);
+  const labelOverride = readSaacmsAnnotation3(inner, "saacmsLabel");
+  const label = labelOverride ?? defaultLabel(jsName);
+  const literals = tryGetStringLiteralUnion2(inner);
+  if (literals !== undefined) {
+    const options = literals.map(literalToOption);
+    const isRadio = readSaacmsAnnotation3(inner, "saacmsRadio") === true;
+    return isRadio ? { type: "radio", label, options } : { type: "select", label, options };
+  }
+  if (AST4.isStringKeyword(inner)) {
+    const isMultiline = readSaacmsAnnotation3(inner, "saacmsMultiline") === true;
+    return isMultiline ? { type: "textarea", label } : { type: "text", label };
+  }
+  if (AST4.isNumberKeyword(inner)) {
+    return { type: "number", label };
+  }
+  if (AST4.isBooleanKeyword(inner)) {
+    return {
+      type: "radio",
+      label,
+      options: [
+        { label: "Yes", value: "true" },
+        { label: "No", value: "false" }
+      ]
+    };
+  }
+  if (AST4.isTupleType(inner)) {
+    const elementAst = inner.rest[0]?.type;
+    if (elementAst !== undefined) {
+      const peeledEl = peel(elementAst);
+      if (AST4.isTypeLiteral(peeledEl)) {
+        return {
+          type: "array",
+          label,
+          arrayFields: structToFields(peeledEl)
+        };
+      }
+    }
+    return { type: "text", label };
+  }
+  if (AST4.isTypeLiteral(inner)) {
+    return {
+      type: "object",
+      label,
+      objectFields: structToFields(inner)
+    };
+  }
+  return { type: "text", label };
+}
+function structToFields(struct) {
+  const out = {};
+  for (const ps of struct.propertySignatures) {
+    const name = String(ps.name);
+    out[name] = astToPuckField(ps.type, name);
+  }
+  return out;
+}
+function schemaToPuckFields(coll) {
+  coll = withMediaFields(coll);
+  const root = coll.schema.ast;
+  if (!AST4.isTypeLiteral(root)) {
+    throw new Error(`schemaToPuckFields: root schema for "${coll.slug}" must be a Struct (TypeLiteral); got ${root._tag}`);
+  }
+  return structToFields(root);
+}
+// src/codegen/to-ts-types.ts
+import { Option as Option3, SchemaAST as AST5 } from "effect";
+function readSaacmsAnnotation4(ast, key) {
+  const v = ast.annotations[key];
+  return v === undefined ? undefined : v;
+}
+function isNullKeyword5(ast) {
+  return AST5.isLiteral(ast) && ast.literal === null;
+}
+function innerNode(ast) {
+  let t = ast;
+  if (AST5.isUnion(t)) {
+    const nonNullish = t.types.filter((m) => !AST5.isUndefinedKeyword(m) && !isNullKeyword5(m));
+    if (nonNullish.length === 1 && nonNullish.length !== t.types.length) {
+      t = nonNullish[0];
+    }
+  }
+  while (AST5.isRefinement(t)) {
+    t = t.from;
+  }
+  return t;
+}
+function isDateLikeAst3(ast) {
+  const id = Option3.getOrUndefined(AST5.getIdentifierAnnotation(ast));
+  return id === "DateFromSelf" || id === "Date" || id === "ValidDateFromSelf" || id === "DateFromString" || id === "DateFromNumber";
+}
+function literalToTs(literal) {
+  if (literal === null)
+    return "null";
+  if (typeof literal === "bigint")
+    return `${literal.toString()}n`;
+  return JSON.stringify(literal);
+}
+function astToTsType(ast) {
+  let t = ast;
+  while (AST5.isRefinement(t)) {
+    t = t.from;
+  }
+  if (AST5.isUnion(t)) {
+    const members = t.types.filter((m) => !AST5.isUndefinedKeyword(m));
+    const hasNull = members.some(isNullKeyword5);
+    const nonNull = members.filter((m) => !isNullKeyword5(m));
+    let base;
+    if (nonNull.length > 0 && nonNull.every((m) => AST5.isLiteral(m))) {
+      base = nonNull.map((m) => literalToTs(m.literal)).join(" | ");
+    } else if (nonNull.length === 1) {
+      base = astToTsType(nonNull[0]);
+    } else if (nonNull.length === 0) {
+      base = "never";
+    } else {
+      base = "unknown";
+    }
+    return hasNull ? `${base} | null` : base;
+  }
+  if (AST5.isLiteral(t)) {
+    return literalToTs(t.literal);
+  }
+  if (isDateLikeAst3(t)) {
+    return "string";
+  }
+  if (AST5.isStringKeyword(t)) {
+    return "string";
+  }
+  if (AST5.isNumberKeyword(t)) {
+    return "number";
+  }
+  if (AST5.isBooleanKeyword(t)) {
+    return "boolean";
+  }
+  if (AST5.isTupleType(t)) {
+    const elementAst = t.rest[0]?.type;
+    if (elementAst !== undefined) {
+      const el = astToTsType(elementAst);
+      return el.includes(" | ") ? `(${el})[]` : `${el}[]`;
+    }
+    return "unknown";
+  }
+  if (AST5.isTypeLiteral(t)) {
+    return structToInlineType(t);
+  }
+  return "unknown";
+}
+function structToInlineType(struct) {
+  const props = struct.propertySignatures.map((ps) => emitProperty(ps));
+  if (props.length === 0)
+    return "{}";
+  return `{ ${props.join("; ")} }`;
+}
+function emitProperty(ps) {
+  const inner = innerNode(ps.type);
+  const nameOverride = readSaacmsAnnotation4(inner, "saacmsTsName");
+  const name = nameOverride ?? String(ps.name);
+  const hasUndefinedMember = AST5.isUnion(ps.type) && ps.type.types.some(AST5.isUndefinedKeyword);
+  const optional = ps.isOptional || hasUndefinedMember;
+  const tsType = astToTsType(ps.type);
+  return `${name}${optional ? "?" : ""}: ${tsType}`;
+}
+function pascalCase2(slug) {
+  return slug.split(/[^a-zA-Z0-9]+/).filter((s) => s.length > 0).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+var HEADER = "// generated by saacms — do not edit";
+function schemaToTsType(coll) {
+  coll = withMediaFields(coll);
+  const root = coll.schema.ast;
+  if (!AST5.isTypeLiteral(root)) {
+    throw new Error(`schemaToTsType: root schema for "${coll.slug}" must be a Struct (TypeLiteral); got ${root._tag}`);
+  }
+  const name = pascalCase2(String(coll.slug));
+  const lines = ["id: string;"];
+  for (const ps of root.propertySignatures) {
+    const key = String(ps.name);
+    if (key === "id" || key === "createdAt" || key === "updatedAt")
+      continue;
+    lines.push(`${emitProperty(ps)};`);
+  }
+  lines.push("createdAt: string;");
+  lines.push("updatedAt: string;");
+  const body = lines.map((l) => `  ${l}`).join(`
+`);
+  return `export interface ${name} {
+${body}
+}`;
+}
+function schemaToTsTypes(colls) {
+  return `${HEADER}
+
+${colls.map((c) => schemaToTsType(c)).join(`
+
+`)}`;
+}
+// src/codegen/filter-openapi-for-user.ts
+import { SchemaAST as SchemaAST2 } from "effect";
+async function filterOpenApiForUser(input) {
+  const cloned = structuredClone({
+    paths: input.spec.paths,
+    components: {
+      schemas: { ...input.spec.components.schemas }
+    }
+  });
+  const slugMap = new Map;
+  for (const c of input.collections)
+    slugMap.set(String(c.slug), c);
+  const newPaths = {};
+  for (const [path, item] of Object.entries(cloned.paths)) {
+    if (item == null)
+      continue;
+    const slug = matchSlug(path, slugMap);
+    const coll = slug != null ? slugMap.get(slug) : undefined;
+    const filtered = await filterPathItem(path, item, coll, input.user);
+    if (filtered != null)
+      newPaths[path] = filtered;
+  }
+  const newSchemas = {
+    ...cloned.components.schemas
+  };
+  for (const coll of input.collections) {
+    const recordName = pascalCase3(String(coll.slug));
+    const schemaObj = newSchemas[recordName];
+    if (schemaObj == null)
+      continue;
+    newSchemas[recordName] = await filterFieldsOnSchema(coll, schemaObj, input.user);
+  }
+  const referenced = collectReferenced(newPaths, newSchemas);
+  referenced.add("ProblemDetails");
+  const prunedSchemas = {};
+  for (const [name, s] of Object.entries(newSchemas)) {
+    if (referenced.has(name))
+      prunedSchemas[name] = s;
+  }
+  return {
+    paths: newPaths,
+    components: { schemas: prunedSchemas }
+  };
+}
+function matchSlug(path, slugMap) {
+  const cleaned = path.split(":")[0] ?? path;
+  const segments = cleaned.split("/").filter((s) => s.length > 0);
+  for (const seg of segments) {
+    if (slugMap.has(seg))
+      return seg;
+  }
+  return;
+}
+var METHOD_KEYS = [
+  "get",
+  "put",
+  "post",
+  "patch",
+  "delete",
+  "options",
+  "head",
+  "trace"
+];
+function methodToVerb(path, method) {
+  if (method === "post" && path.includes(":"))
+    return "update";
+  switch (method) {
+    case "get":
+      return "read";
+    case "post":
+      return "create";
+    case "put":
+    case "patch":
+      return "update";
+    case "delete":
+      return "delete";
+    case "options":
+    case "head":
+    case "trace":
+      return "read";
+  }
+}
+async function filterPathItem(path, item, coll, user) {
+  if (coll == null)
+    return item;
+  const mutable = item;
+  let kept = 0;
+  let seenOperation = false;
+  for (const m of METHOD_KEYS) {
+    if (mutable[m] == null)
+      continue;
+    seenOperation = true;
+    const verb = methodToVerb(path, m);
+    const predicate = coll.access?.[verb];
+    if (predicate == null) {
+      kept++;
+      continue;
+    }
+    const allowed = await evaluatePredicateAllow(predicate, user);
+    if (allowed)
+      kept++;
+    else
+      delete mutable[m];
+  }
+  if (seenOperation && kept === 0)
+    return null;
+  return mutable;
+}
+async function evaluatePredicateAllow(predicate, user) {
+  try {
+    const result = await Promise.resolve(predicate({ user, record: undefined }));
+    return result !== false;
+  } catch {
+    return true;
+  }
+}
+async function filterFieldsOnSchema(coll, schemaObj, user) {
+  const ast = coll.schema.ast;
+  if (!SchemaAST2.isTypeLiteral(ast))
+    return schemaObj;
+  if (schemaObj.properties == null)
+    return schemaObj;
+  const toRemove = new Set;
+  for (const prop of ast.propertySignatures) {
+    const fa = findFieldAccessDeep(prop);
+    const readPred = fa?.read;
+    if (readPred == null)
+      continue;
+    const allowed = await evaluatePredicateAllow(readPred, user);
+    if (!allowed)
+      toRemove.add(String(prop.name));
+  }
+  if (toRemove.size === 0)
+    return schemaObj;
+  const nextProps = {};
+  for (const [k, v] of Object.entries(schemaObj.properties)) {
+    if (!toRemove.has(k))
+      nextProps[k] = v;
+  }
+  const next = { ...schemaObj, properties: nextProps };
+  if (schemaObj.required != null) {
+    const nextRequired = schemaObj.required.filter((r) => !toRemove.has(r));
+    if (nextRequired.length === 0)
+      delete next["required"];
+    else
+      next["required"] = nextRequired;
+  }
+  return next;
+}
+function findFieldAccessDeep(prop) {
+  const sig = readFieldAccess(prop);
+  if (sig != null)
+    return sig;
+  let current = prop.type;
+  for (let depth = 0;depth < 8 && current != null; depth++) {
+    const here = readFieldAccess(current);
+    if (here != null)
+      return here;
+    const next = current.from;
+    if (next == null || next === current)
+      break;
+    current = next;
+  }
+  return;
+}
+function readFieldAccess(annotated) {
+  const a = annotated.annotations;
+  const fa = a["saacmsAccess"];
+  if (fa != null && typeof fa === "object")
+    return fa;
+  return;
+}
+function collectReferenced(paths, schemas) {
+  const referenced = new Set;
+  walkRefs(paths, referenced);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const name of [...referenced]) {
+      const s = schemas[name];
+      if (s == null)
+        continue;
+      const before = referenced.size;
+      walkRefs(s, referenced);
+      if (referenced.size > before)
+        changed = true;
+    }
+  }
+  return referenced;
+}
+function walkRefs(value, out) {
+  if (value == null)
+    return;
+  if (Array.isArray(value)) {
+    for (const v of value)
+      walkRefs(v, out);
+    return;
+  }
+  if (typeof value !== "object")
+    return;
+  const obj = value;
+  const ref = obj["$ref"];
+  if (typeof ref === "string") {
+    const m = ref.match(/^#\/components\/schemas\/(.+)$/);
+    if (m != null && m[1] != null)
+      out.add(m[1]);
+  }
+  for (const k of Object.keys(obj))
+    walkRefs(obj[k], out);
+}
+function pascalCase3(input) {
+  return input.split(/[-_\s]+/).filter((s) => s.length > 0).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+export { camelToSnakeCase, slugToTableName, assertNoTableNameCollisions, schemaToD1Migration, schemaToD1Migrations, normalizeDateSchemas, schemaToOpenApiSchema, collectionToOpenApiPaths, schemaToDrizzle, fingerprintBlockSchema, fingerprintToString, diffBlockSchemas, contentMigrationModuleSource, detectPendingContentMigrations, defaultLabel, schemaToPuckFields, schemaToTsType, schemaToTsTypes, filterOpenApiForUser };