@sequenceholdings/orm 0.1.0 → 0.1.2

package/dist/authoring.cjs

@@ -0,0 +1,794 @@
+'use strict';
+
+var crypto = require('crypto');
+var zod = require('zod');
+var jiti = require('jiti');
+var promises = require('fs/promises');
+var module$1 = require('module');
+var path = require('path');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/authoring/columns.ts
+var COLUMN_BRAND = "seq-column";
+var ENUM_BRAND = "seq-enum";
+function isEnumRef(value) {
+  return typeof value === "object" && value !== null && value.kind === ENUM_BRAND;
+}
+var COLUMN_DEFAULT_FNS = ["gen_random_uuid()", "now()"];
+function deriveColumnName(propertyName) {
+  return propertyName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+var ColumnBuilder = class {
+  kind = COLUMN_BRAND;
+  state;
+  constructor(type, columnName) {
+    this.state = {
+      type,
+      columnName,
+      primaryKey: false,
+      notNull: false,
+      unique: false,
+      hasDefault: false,
+      defaultValue: void 0,
+      defaultFn: void 0,
+      description: void 0,
+      renamedFrom: void 0,
+      cast: void 0,
+      deprecated: false
+    };
+  }
+  /** Marks this column as (part of) the primary key. Implies NOT NULL. */
+  primaryKey() {
+    this.state.primaryKey = true;
+    return this;
+  }
+  notNull() {
+    this.state.notNull = true;
+    return this;
+  }
+  unique() {
+    this.state.unique = true;
+    return this;
+  }
+  /**
+   * Column default: a literal, or one of the allowlisted SQL functions
+   * (`'gen_random_uuid()'` / `'now()'`), which serialize as `defaultFn`.
+   */
+  default(value) {
+    if (value === "gen_random_uuid()" || value === "now()") {
+      this.state.defaultFn = value;
+      this.state.hasDefault = false;
+      this.state.defaultValue = void 0;
+      return this;
+    }
+    this.state.hasDefault = true;
+    this.state.defaultValue = value;
+    this.state.defaultFn = void 0;
+    return this;
+  }
+  description(text) {
+    this.state.description = text;
+    return this;
+  }
+  /** Migration rename hint: the previous Postgres column name. */
+  renamedFrom(previousColumnName) {
+    this.state.renamedFrom = previousColumnName;
+    return this;
+  }
+  /** Migration cast hint: the `USING` SQL applied when this column changes type. */
+  cast(usingSql) {
+    this.state.cast = usingSql;
+    return this;
+  }
+  /** Emits `@deprecated` in the generated SDL; the column stays queryable. */
+  deprecated() {
+    this.state.deprecated = true;
+    return this;
+  }
+  /** Whether `.primaryKey()` was called — collected into the table-level PK. */
+  get isPrimaryKey() {
+    return this.state.primaryKey;
+  }
+  /** The enum name when this is an enum column, else undefined. */
+  get enumName() {
+    return typeof this.state.type === "object" ? this.state.type.enum : void 0;
+  }
+  /** Postgres column name: explicit override, else snake_case of the property name. */
+  columnNameFor(propertyName) {
+    return this.state.columnName ?? deriveColumnName(propertyName);
+  }
+  /** Serialize to a canonical v2 column. Validation happens in serializeNamespace. */
+  toCanonicalColumn(propertyName) {
+    const column = {
+      name: propertyName,
+      columnName: this.columnNameFor(propertyName),
+      type: typeof this.state.type === "object" ? { enum: this.state.type.enum } : this.state.type,
+      nullable: !(this.state.notNull || this.state.primaryKey),
+      unique: this.state.unique,
+      deprecated: this.state.deprecated
+    };
+    if (this.state.hasDefault) column.default = this.state.defaultValue ?? null;
+    if (this.state.defaultFn !== void 0) column.defaultFn = this.state.defaultFn;
+    if (this.state.description !== void 0) column.description = this.state.description;
+    if (this.state.renamedFrom !== void 0) column.renamedFrom = this.state.renamedFrom;
+    if (this.state.cast !== void 0) column.cast = this.state.cast;
+    return column;
+  }
+};
+function isColumnBuilder(value) {
+  return typeof value === "object" && value !== null && value.kind === COLUMN_BRAND;
+}
+var scalar = (type) => (columnName) => new ColumnBuilder(type, columnName);
+var t = {
+  uuid: scalar("uuid"),
+  text: scalar("text"),
+  integer: scalar("integer"),
+  bigint: scalar("bigint"),
+  numeric: scalar("numeric"),
+  double: scalar("double"),
+  boolean: scalar("boolean"),
+  timestamptz: scalar("timestamptz"),
+  date: scalar("date"),
+  jsonb: scalar("jsonb"),
+  enum: (ref, columnName) => new ColumnBuilder({ enum: ref.name }, columnName)
+};
+
+// src/constants.ts
+var NAMESPACE_PATTERN = /^[a-z][a-z0-9_]{0,40}$/;
+var IDENTIFIER_PATTERN = /^[a-z][a-z0-9_]*$/;
+var MAX_IDENTIFIER_LENGTH = 63;
+var SYNCED_SOURCE_PATTERN = /^gold\.[a-z][a-z0-9_]*$/;
+var HASH_DOMAIN = "sequence-orm-definitions\0";
+
+// src/errors.ts
+var OrmDefinitionError = class extends Error {
+  constructor(message, file) {
+    super(file ? `${file}: ${message}` : message);
+    this.file = file;
+  }
+  name = "OrmDefinitionError";
+};
+
+// src/authoring/registry.ts
+var CONTEXT_STACK_KEY = Symbol.for("sequence.orm.authoring.context-stack.v2");
+function contextStack() {
+  const holder = globalThis;
+  const existing = holder[CONTEXT_STACK_KEY];
+  if (Array.isArray(existing)) {
+    return existing;
+  }
+  const created = [];
+  holder[CONTEXT_STACK_KEY] = created;
+  return created;
+}
+function beginAuthoringContext() {
+  const context = { currentFile: void 0, tables: [], enums: [], configs: [] };
+  contextStack().push(context);
+  return context;
+}
+function endAuthoringContext(context) {
+  const stack = contextStack();
+  const top = stack[stack.length - 1];
+  if (top !== context) {
+    throw new Error("endAuthoringContext: the given context is not the active one \u2014 begin/end calls are mismatched");
+  }
+  stack.pop();
+}
+function activeAuthoringContext() {
+  const stack = contextStack();
+  return stack[stack.length - 1];
+}
+function register(bucket, value) {
+  const context = activeAuthoringContext();
+  if (!context) return;
+  context[bucket].push({ value, file: context.currentFile });
+}
+function registerTable(value) {
+  register("tables", value);
+}
+function registerEnum(value) {
+  register("enums", value);
+}
+function registerNamespaceConfig(value) {
+  register("configs", value);
+}
+
+// src/authoring/table.ts
+var TABLE_BRAND = "seq-table";
+var LINK_BRAND = "seq-link";
+function toOne(target, options) {
+  return {
+    kind: LINK_BRAND,
+    linkKind: "toOne",
+    target,
+    on: options.on,
+    references: options.references,
+    enforce: options.enforce ?? false,
+    description: options.description
+  };
+}
+function toMany(target, options) {
+  return {
+    kind: LINK_BRAND,
+    linkKind: "toMany",
+    target,
+    on: options.on,
+    references: options.references,
+    enforce: false,
+    description: options.description
+  };
+}
+function toPlatformUser(options) {
+  return {
+    kind: LINK_BRAND,
+    linkKind: "toPlatformUser",
+    target: void 0,
+    on: options.on,
+    references: options.references,
+    enforce: false,
+    description: options.description
+  };
+}
+function isSeqLink(value) {
+  return typeof value === "object" && value !== null && value.kind === LINK_BRAND;
+}
+function isSeqTable(value) {
+  return typeof value === "object" && value !== null && value.kind === TABLE_BRAND;
+}
+function assertIdentifier({ value, what, file }) {
+  if (!IDENTIFIER_PATTERN.test(value) || value.length > MAX_IDENTIFIER_LENGTH) {
+    throw new OrmDefinitionError(
+      `${what} "${value}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`,
+      file
+    );
+  }
+}
+function defineTable(name, columns, config = {}) {
+  const file = activeAuthoringContext()?.currentFile;
+  assertIdentifier({ value: name, what: "table name", file });
+  const entries = Object.entries(columns);
+  if (entries.length === 0) {
+    throw new OrmDefinitionError(`table "${name}" declares no columns`, file);
+  }
+  const seenColumnNames = /* @__PURE__ */ new Map();
+  for (const [propertyName, builder] of entries) {
+    if (!isColumnBuilder(builder)) {
+      throw new OrmDefinitionError(
+        `table "${name}": column "${propertyName}" is not a column builder \u2014 use the t.* factories (t.uuid(), t.text(), \u2026)`,
+        file
+      );
+    }
+    const columnName = builder.columnNameFor(propertyName);
+    assertIdentifier({ value: columnName, what: `table "${name}": column "${propertyName}" column name`, file });
+    const existing = seenColumnNames.get(columnName);
+    if (existing !== void 0) {
+      throw new OrmDefinitionError(
+        `table "${name}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
+        file
+      );
+    }
+    seenColumnNames.set(columnName, propertyName);
+  }
+  const table = { kind: TABLE_BRAND, tableName: name, columns, config, source: void 0, file };
+  registerTable(table);
+  return table;
+}
+function defineSyncedTable(name, config) {
+  const file = activeAuthoringContext()?.currentFile;
+  assertIdentifier({ value: name, what: "table name", file });
+  if (!SYNCED_SOURCE_PATTERN.test(config.source)) {
+    throw new OrmDefinitionError(
+      `synced table "${name}": source "${config.source}" must match ${SYNCED_SOURCE_PATTERN} (gold layer only)`,
+      file
+    );
+  }
+  const table = {
+    kind: TABLE_BRAND,
+    tableName: name,
+    columns: {},
+    config: config.description !== void 0 ? { description: config.description } : {},
+    source: config.source,
+    file
+  };
+  registerTable(table);
+  return table;
+}
+function defineEnum(name, values) {
+  const file = activeAuthoringContext()?.currentFile;
+  assertIdentifier({ value: name, what: "enum name", file });
+  if (values.length === 0 || values.length > 100) {
+    throw new OrmDefinitionError(`enum "${name}" must declare between 1 and 100 values`, file);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (value.length === 0 || value.length > MAX_IDENTIFIER_LENGTH) {
+      throw new OrmDefinitionError(
+        `enum "${name}": value ${JSON.stringify(value)} must be 1-${MAX_IDENTIFIER_LENGTH} characters`,
+        file
+      );
+    }
+    if (seen.has(value)) {
+      throw new OrmDefinitionError(`enum "${name}" declares duplicate value "${value}"`, file);
+    }
+    seen.add(value);
+  }
+  const ref = { kind: ENUM_BRAND, name, values: [...values] };
+  registerEnum(ref);
+  return ref;
+}
+var CANONICAL_FORMAT = 2;
+var IDENTIFIER_RE = /^[a-z][a-z0-9_]*$/;
+var identifier = zod.z.string().min(1).max(63).regex(IDENTIFIER_RE);
+var COLUMN_TYPES = [
+  "uuid",
+  "text",
+  "integer",
+  "bigint",
+  "numeric",
+  "double",
+  "boolean",
+  "timestamptz",
+  "date",
+  "jsonb"
+];
+var columnTypeSchema = zod.z.enum(COLUMN_TYPES);
+var canonicalEnumSchema = zod.z.object({
+  name: identifier,
+  values: zod.z.array(zod.z.string().min(1).max(63)).min(1).max(100)
+});
+var canonicalColumnSchema = zod.z.object({
+  /** Property name in TS (camelCase); columnName is the Postgres name. */
+  name: zod.z.string().min(1).max(63),
+  columnName: identifier,
+  type: zod.z.union([columnTypeSchema, zod.z.object({ enum: identifier })]),
+  nullable: zod.z.boolean().default(true),
+  unique: zod.z.boolean().default(false),
+  /** Literal default, or one of the allowlisted SQL functions. */
+  default: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]).optional(),
+  defaultFn: zod.z.enum(["gen_random_uuid()", "now()"]).optional(),
+  description: zod.z.string().max(500).optional(),
+  /** Migration hints — same semantics as v1. */
+  renamedFrom: identifier.optional(),
+  cast: zod.z.string().max(200).optional(),
+  deprecated: zod.z.boolean().default(false)
+});
+var canonicalLinkSchema = zod.z.object({
+  name: zod.z.string().min(1).max(63),
+  kind: zod.z.enum(["toOne", "toMany", "toPlatformUser"]),
+  /** Target table name (namespace-local). Absent for toPlatformUser. */
+  target: identifier.optional(),
+  /** FK column on the owning side (toOne/toPlatformUser: on this table; toMany: on the target). */
+  on: identifier,
+  /** Referenced column on the target (default: target's PK / platform user `sub`). */
+  references: identifier.optional(),
+  /** enforce: true emits a real FK constraint (same-namespace toOne only). */
+  enforce: zod.z.boolean().default(false),
+  description: zod.z.string().max(500).optional()
+});
+var canonicalIndexSchema = zod.z.object({
+  columns: zod.z.array(identifier).min(1),
+  unique: zod.z.boolean().default(false),
+  name: identifier.optional()
+});
+var policyVariantSchema = zod.z.object({
+  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
+  when: zod.z.string().min(1).max(1e3),
+  /** Exactly one of: allow-all bypass, or a row predicate. */
+  allow: zod.z.literal(true).optional(),
+  policy: zod.z.string().min(1).max(2e3).optional()
+}).refine((v) => v.allow === true !== (typeof v.policy === "string"), {
+  message: "A variant declares exactly one of allow: true or policy"
+});
+var policyExpressionSchema = zod.z.union([
+  zod.z.string().min(1).max(2e3),
+  zod.z.object({
+    default: zod.z.string().min(1).max(2e3),
+    variants: zod.z.array(policyVariantSchema).max(10).default([])
+  })
+]);
+var canonicalPoliciesSchema = zod.z.object({
+  read: policyExpressionSchema.optional(),
+  write: policyExpressionSchema.optional()
+});
+var canonicalActionSchema = zod.z.object({
+  name: identifier,
+  requires: zod.z.string().max(1e3).optional(),
+  params: zod.z.record(zod.z.string(), zod.z.object({
+    type: columnTypeSchema,
+    nullable: zod.z.boolean().default(false)
+  })).default({}),
+  executes: zod.z.string().min(1).max(1e4),
+  returns: zod.z.enum(["rows", "rowsAffected", "scalar"]).default("rowsAffected"),
+  audit: zod.z.object({ action: zod.z.string(), resource: zod.z.string() }).optional()
+});
+var canonicalTableSchema = zod.z.object({
+  table: identifier,
+  description: zod.z.string().max(2e3).optional(),
+  /** Table-level rename hint (new in v2). */
+  renamedFrom: identifier.optional(),
+  /** Synced/reflected read-only tables (`source: gold.*`) — v1 semantics. */
+  source: zod.z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
+  columns: zod.z.array(canonicalColumnSchema).default([]),
+  primaryKey: zod.z.array(identifier).min(1).max(8).optional(),
+  links: zod.z.array(canonicalLinkSchema).default([]),
+  indexes: zod.z.array(canonicalIndexSchema).default([]),
+  policies: canonicalPoliciesSchema.default({}),
+  actions: zod.z.array(canonicalActionSchema).default([])
+});
+var canonicalDefinitionSchema = zod.z.object({
+  definition_format: zod.z.literal(CANONICAL_FORMAT),
+  namespace: identifier.max(41),
+  description: zod.z.string().max(2e3).optional(),
+  enums: zod.z.array(canonicalEnumSchema).default([]),
+  tables: zod.z.array(canonicalTableSchema).min(0).max(500),
+  /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
+  capabilities: zod.z.object({
+    roles: zod.z.unknown().optional(),
+    uses: zod.z.array(zod.z.string()).default([])
+  }).default({ uses: [] })
+});
+function normalizeCanonical(definition) {
+  const sortByName = (items) => [...items].sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    ...definition,
+    enums: sortByName(definition.enums),
+    tables: [...definition.tables].sort((a, b) => a.table.localeCompare(b.table)).map((t2) => ({
+      ...t2,
+      links: sortByName(t2.links),
+      indexes: [...t2.indexes].sort((a, b) => (a.name ?? a.columns.join("_")).localeCompare(b.name ?? b.columns.join("_"))),
+      actions: sortByName(t2.actions)
+    }))
+  };
+}
+function stableJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([a], [b]) => a < b ? -1 : 1).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableJson(entryValue)}`);
+  return `{${entries.join(",")}}`;
+}
+
+// src/authoring/namespace.ts
+var NAMESPACE_CONFIG_BRAND = "seq-namespace-config";
+function isSeqNamespaceConfig(value) {
+  return typeof value === "object" && value !== null && value.kind === NAMESPACE_CONFIG_BRAND;
+}
+function defineNamespace(input) {
+  const file = activeAuthoringContext()?.currentFile;
+  if (!NAMESPACE_PATTERN.test(input.namespace)) {
+    throw new OrmDefinitionError(`namespace "${input.namespace}" must match ${NAMESPACE_PATTERN}`, file);
+  }
+  const config = {
+    kind: NAMESPACE_CONFIG_BRAND,
+    namespace: input.namespace,
+    description: input.description,
+    capabilities: input.capabilities ?? {},
+    file
+  };
+  registerNamespaceConfig(config);
+  return config;
+}
+function serializeNamespace(input) {
+  const { config, tables } = input;
+  const enums = input.enums ?? [];
+  const tablesByName = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    const existing = tablesByName.get(table.tableName);
+    if (existing) {
+      throw new OrmDefinitionError(
+        `duplicate table "${table.tableName}" (defined in ${describeFile(existing)} and ${describeFile(table)})`,
+        table.file
+      );
+    }
+    tablesByName.set(table.tableName, table);
+  }
+  const enumsByName = /* @__PURE__ */ new Map();
+  for (const ref of enums) {
+    if (enumsByName.has(ref.name)) {
+      throw new OrmDefinitionError(`duplicate enum "${ref.name}"`, config.file);
+    }
+    enumsByName.set(ref.name, ref);
+  }
+  const canonicalTables = tables.map((table) => buildCanonicalTable({ table, tablesByName, enumsByName }));
+  const canonicalEnums = [...enumsByName.values()].map((ref) => ({
+    name: ref.name,
+    values: [...ref.values]
+  }));
+  const candidate = {
+    definition_format: CANONICAL_FORMAT,
+    namespace: config.namespace,
+    enums: canonicalEnums,
+    tables: canonicalTables,
+    capabilities: {
+      ...config.capabilities.roles !== void 0 ? { roles: config.capabilities.roles } : {},
+      uses: [...config.capabilities.uses ?? []]
+    }
+  };
+  if (config.description !== void 0) candidate.description = config.description;
+  let parsed;
+  try {
+    parsed = canonicalDefinitionSchema.parse(candidate);
+  } catch (error) {
+    if (error instanceof zod.z.ZodError) {
+      throw new OrmDefinitionError(`namespace "${config.namespace}": ${formatZodIssues(error)}`, config.file);
+    }
+    throw error;
+  }
+  return normalizeCanonical(parsed);
+}
+function computeCanonicalHash(definition) {
+  return crypto.createHash("sha256").update(HASH_DOMAIN).update(stableJson(definition)).digest("hex");
+}
+function buildCanonicalTable({ table, tablesByName, enumsByName }) {
+  const candidate = {
+    table: table.tableName,
+    columns: [],
+    links: [],
+    indexes: [],
+    policies: {},
+    actions: []
+  };
+  if (table.config.description !== void 0) candidate.description = table.config.description;
+  if (table.config.renamedFrom !== void 0) candidate.renamedFrom = table.config.renamedFrom;
+  if (table.source !== void 0) candidate.source = table.source;
+  const columnLevelPk = [];
+  for (const [propertyName, builder] of Object.entries(table.columns)) {
+    const column = builder.toCanonicalColumn(propertyName);
+    const enumName = builder.enumName;
+    if (enumName !== void 0 && !enumsByName.has(enumName)) {
+      throw new OrmDefinitionError(
+        `table "${table.tableName}": column "${propertyName}" references enum "${enumName}" which is not passed to serializeNamespace \u2014 declare it with defineEnum and include it`,
+        table.file
+      );
+    }
+    if (builder.isPrimaryKey) columnLevelPk.push(column.columnName);
+    candidate.columns?.push(column);
+  }
+  if (table.config.primaryKey !== void 0) {
+    if (columnLevelPk.length > 0) {
+      throw new OrmDefinitionError(
+        `table "${table.tableName}": declare the primary key either with .primaryKey() on columns or with config.primaryKey \u2014 not both`,
+        table.file
+      );
+    }
+    candidate.primaryKey = table.config.primaryKey.map(
+      (ref) => resolveColumnRef({ table, ref, role: "primaryKey" })
+    );
+  } else if (columnLevelPk.length > 0) {
+    candidate.primaryKey = columnLevelPk;
+  }
+  for (const index of table.config.indexes ?? []) {
+    const entry = {
+      columns: index.columns.map((ref) => resolveColumnRef({ table, ref, role: "index" }))
+    };
+    if (index.unique !== void 0) entry.unique = index.unique;
+    if (index.name !== void 0) entry.name = index.name;
+    candidate.indexes?.push(entry);
+  }
+  for (const [linkName, link] of Object.entries(table.config.links ?? {})) {
+    candidate.links?.push(buildCanonicalLink({ table, linkName, link, tablesByName }));
+  }
+  const policies = {};
+  if (table.config.policies?.read !== void 0) policies.read = toCanonicalPolicy(table.config.policies.read);
+  if (table.config.policies?.write !== void 0) policies.write = toCanonicalPolicy(table.config.policies.write);
+  candidate.policies = policies;
+  for (const action of table.config.actions ?? []) {
+    candidate.actions?.push({
+      name: action.name,
+      ...action.requires !== void 0 ? { requires: action.requires } : {},
+      params: Object.fromEntries(
+        Object.entries(action.params ?? {}).map(([name, param]) => [
+          name,
+          { type: param.type, nullable: param.nullable ?? false }
+        ])
+      ),
+      executes: action.executes,
+      returns: action.returns ?? "rowsAffected",
+      ...action.audit !== void 0 ? { audit: action.audit } : {}
+    });
+  }
+  try {
+    return canonicalTableSchema.parse(candidate);
+  } catch (error) {
+    if (error instanceof zod.z.ZodError) {
+      throw new OrmDefinitionError(`table "${table.tableName}": ${formatZodIssues(error)}`, table.file);
+    }
+    throw error;
+  }
+}
+function buildCanonicalLink({
+  table,
+  linkName,
+  link,
+  tablesByName
+}) {
+  const fail = (message) => {
+    throw new OrmDefinitionError(`table "${table.tableName}": link "${linkName}" ${message}`, table.file);
+  };
+  if (link.enforce && link.linkKind !== "toOne") {
+    return fail("sets enforce: true, which is only supported on toOne links");
+  }
+  if (link.linkKind === "toPlatformUser") {
+    if (link.target !== void 0) return fail("is toPlatformUser and must not declare a target table");
+    return {
+      name: linkName,
+      kind: "toPlatformUser",
+      on: resolveColumnRef({ table, ref: link.on, role: `link "${linkName}" on` }),
+      ...link.references !== void 0 ? { references: deriveColumnName(link.references) } : {},
+      enforce: false,
+      ...link.description !== void 0 ? { description: link.description } : {}
+    };
+  }
+  const target = resolveTableRef({ ref: link.target, fail });
+  if (!tablesByName.has(target.tableName)) {
+    return fail(`targets table "${target.tableName}" which is not part of this namespace`);
+  }
+  const owningSide = link.linkKind === "toOne" ? table : target;
+  return {
+    name: linkName,
+    kind: link.linkKind,
+    target: target.tableName,
+    on: resolveColumnRef({ table: owningSide, ref: link.on, role: `link "${linkName}" on` }),
+    ...link.references !== void 0 ? { references: resolveColumnRef({ table: target, ref: link.references, role: `link "${linkName}" references` }) } : {},
+    enforce: link.enforce,
+    ...link.description !== void 0 ? { description: link.description } : {}
+  };
+}
+function resolveTableRef({ ref, fail }) {
+  if (ref === void 0) return fail("declares no target table");
+  if (typeof ref !== "function") return ref;
+  let resolved;
+  try {
+    resolved = ref();
+  } catch (error) {
+    return fail(
+      `target thunk threw (${error instanceof Error ? error.message : String(error)}) \u2014 lazy refs resolve at serialize time; make sure the target module ran`
+    );
+  }
+  if (!isSeqTable(resolved)) return fail("target thunk did not return a table defined with defineTable");
+  return resolved;
+}
+function resolveColumnRef({ table, ref, role }) {
+  const direct = table.columns[ref];
+  if (direct) return direct.columnNameFor(ref);
+  for (const [propertyName, builder] of Object.entries(table.columns)) {
+    if (builder.columnNameFor(propertyName) === ref) return ref;
+  }
+  const known = Object.keys(table.columns).join(", ");
+  throw new OrmDefinitionError(
+    `table "${table.tableName}": ${role} references unknown column "${ref}" (known columns: ${known || "none"})`,
+    table.file
+  );
+}
+function toCanonicalPolicy(policy) {
+  if (typeof policy === "string") return policy;
+  return {
+    default: policy.default,
+    variants: (policy.variants ?? []).map((variant) => ({
+      when: variant.when,
+      ...variant.allow === true ? { allow: true } : {},
+      ...variant.policy !== void 0 ? { policy: variant.policy } : {}
+    }))
+  };
+}
+function describeFile(table) {
+  return table.file ?? "<unknown file>";
+}
+function formatZodIssues(error) {
+  return error.issues.map((issue) => issue.path.length > 0 ? `${issue.path.join(".")}: ${issue.message}` : issue.message).join("; ");
+}
+var NAMESPACE_CONFIG_FILE = "sequence.config.ts";
+var SCHEMA_DIR = "schema";
+async function loadNamespaceFromDir(dir, options = {}) {
+  const root = await promises.realpath(dir).catch(() => {
+    throw new OrmDefinitionError(`namespace directory not found: ${dir}`);
+  });
+  const configPath = path.join(root, NAMESPACE_CONFIG_FILE);
+  const configStat = await promises.stat(configPath).catch(() => void 0);
+  if (!configStat?.isFile()) {
+    throw new OrmDefinitionError(`${NAMESPACE_CONFIG_FILE} not found in ${dir}`);
+  }
+  const schemaFiles = await listSchemaFiles(root);
+  const files = [NAMESPACE_CONFIG_FILE, ...schemaFiles];
+  purgeModuleCache(root);
+  const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('authoring.cjs', document.baseURI).href)), {
+    interopDefault: true,
+    fsCache: false,
+    ...options.ormModulePath !== void 0 ? { alias: { "@sequenceholdings/orm": options.ormModulePath } } : {}
+  });
+  const context = beginAuthoringContext();
+  try {
+    for (const file of files) {
+      context.currentFile = file;
+      try {
+        await jiti$1.import(path.join(root, file));
+      } catch (error) {
+        if (error instanceof Error && error.name === "OrmDefinitionError") throw error;
+        throw new OrmDefinitionError(
+          `failed to load: ${error instanceof Error ? error.message : String(error)}`,
+          file
+        );
+      }
+    }
+  } finally {
+    context.currentFile = void 0;
+    endAuthoringContext(context);
+  }
+  const configs = [];
+  for (const entry of context.configs) {
+    if (isSeqNamespaceConfig(entry.value)) configs.push({ value: entry.value, file: entry.file });
+  }
+  const configEntry = configs[0];
+  if (!configEntry) {
+    throw new OrmDefinitionError(
+      "no namespace config registered \u2014 sequence.config.ts must call defineNamespace(...) at import time",
+      NAMESPACE_CONFIG_FILE
+    );
+  }
+  if (configs.length > 1) {
+    const where = configs.map((entry) => entry.file ?? "<unknown file>").join(", ");
+    throw new OrmDefinitionError(
+      `defineNamespace called ${configs.length} times (${where}) \u2014 declare exactly one namespace config`
+    );
+  }
+  const tables = [];
+  for (const entry of context.tables) {
+    if (isSeqTable(entry.value)) tables.push(entry.value);
+  }
+  if (tables.length === 0) {
+    throw new OrmDefinitionError(
+      `no tables registered \u2014 ${SCHEMA_DIR}/*.ts modules must call defineTable(...) at import time`
+    );
+  }
+  const enums = [];
+  for (const entry of context.enums) {
+    if (isEnumRef(entry.value)) enums.push(entry.value);
+  }
+  const canonical = serializeNamespace({ config: configEntry.value, tables, enums });
+  return { canonical, hash: computeCanonicalHash(canonical), files };
+}
+async function listSchemaFiles(root) {
+  const schemaDir = path.join(root, SCHEMA_DIR);
+  const entries = await promises.readdir(schemaDir, { withFileTypes: true }).catch(() => []);
+  return entries.filter(
+    (entry) => entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts") && !entry.name.startsWith(".")
+  ).map((entry) => path.join(SCHEMA_DIR, entry.name)).sort();
+}
+function purgeModuleCache(root) {
+  const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('authoring.cjs', document.baseURI).href)));
+  const prefix = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+  for (const key of Object.keys(require2.cache)) {
+    if (key.startsWith(prefix)) delete require2.cache[key];
+  }
+}
+
+exports.COLUMN_BRAND = COLUMN_BRAND;
+exports.COLUMN_DEFAULT_FNS = COLUMN_DEFAULT_FNS;
+exports.ColumnBuilder = ColumnBuilder;
+exports.ENUM_BRAND = ENUM_BRAND;
+exports.LINK_BRAND = LINK_BRAND;
+exports.NAMESPACE_CONFIG_BRAND = NAMESPACE_CONFIG_BRAND;
+exports.NAMESPACE_CONFIG_FILE = NAMESPACE_CONFIG_FILE;
+exports.SCHEMA_DIR = SCHEMA_DIR;
+exports.TABLE_BRAND = TABLE_BRAND;
+exports.activeAuthoringContext = activeAuthoringContext;
+exports.beginAuthoringContext = beginAuthoringContext;
+exports.computeCanonicalHash = computeCanonicalHash;
+exports.defineEnum = defineEnum;
+exports.defineNamespace = defineNamespace;
+exports.defineSyncedTable = defineSyncedTable;
+exports.defineTable = defineTable;
+exports.deriveColumnName = deriveColumnName;
+exports.endAuthoringContext = endAuthoringContext;
+exports.isColumnBuilder = isColumnBuilder;
+exports.isEnumRef = isEnumRef;
+exports.isSeqLink = isSeqLink;
+exports.isSeqNamespaceConfig = isSeqNamespaceConfig;
+exports.isSeqTable = isSeqTable;
+exports.loadNamespaceFromDir = loadNamespaceFromDir;
+exports.serializeNamespace = serializeNamespace;
+exports.t = t;
+exports.toMany = toMany;
+exports.toOne = toOne;
+exports.toPlatformUser = toPlatformUser;
+//# sourceMappingURL=authoring.cjs.map
+//# sourceMappingURL=authoring.cjs.map