@lunora/codegen 1.0.0-alpha.55 → 1.0.0-alpha.57

package/dist/packem_shared/discoverSchema-BJp5_T4o.mjs

@@ -1,906 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { Node, SyntaxKind } from 'ts-morph';
-import { diagnosticAt } from './CodegenDiagnosticError-DyQ5FwkM.mjs';
-import { a as parseObjectShape } from './parse-validator-BDGV8iue.mjs';
-import { createRequire } from 'node:module';
-import { join } from 'node:path';
-
-const renderLiteralValue = (value) => {
-  switch (typeof value) {
-    case "bigint": {
-      return value.toString();
-    }
-    case "boolean":
-    case "number": {
-      return String(value);
-    }
-    case "string": {
-      return JSON.stringify(value);
-    }
-    default: {
-      return value === null ? "null" : void 0;
-    }
-  }
-};
-const columnMetaToIR = (column) => {
-  const hasDefault = column?.["defaultValue"] !== void 0 || column?.["defaultFn"] !== void 0 || column?.["serverDefault"] !== void 0;
-  return {
-    ...hasDefault ? { hasDefault: true } : {},
-    ...column?.["onUpdateFn"] === void 0 ? {} : { hasOnUpdate: true },
-    notNull: column?.["notNull"] ?? true,
-    ...column?.["unique"] === true ? { unique: true } : {}
-  };
-};
-const runtimeValidatorToIR = (validator) => {
-  const meta = validator?._meta ?? {};
-  const kind = validator?.kind ?? "unknown";
-  const ir = { column: columnMetaToIR(meta["column"]), kind };
-  switch (kind) {
-    case "array":
-    case "optional": {
-      ir.inner = runtimeValidatorToIR(meta["inner"]);
-      break;
-    }
-    case "id": {
-      ir.tableName = meta["tableName"];
-      break;
-    }
-    case "literal": {
-      ir.literalValue = renderLiteralValue(meta["value"]);
-      break;
-    }
-    case "object": {
-      const shape = meta["shape"] ?? {};
-      ir.shape = Object.fromEntries(Object.entries(shape).map(([name, child]) => [name, runtimeValidatorToIR(child)]));
-      break;
-    }
-    case "record": {
-      ir.valueType = runtimeValidatorToIR(meta["valueValidator"]);
-      if (meta["keyValidator"] !== void 0) {
-        ir.keyType = runtimeValidatorToIR(meta["keyValidator"]);
-      }
-      break;
-    }
-    case "storage": {
-      if (typeof meta["bucket"] === "string") {
-        ir.bucket = meta["bucket"];
-      }
-      break;
-    }
-    case "union": {
-      const members = meta["members"] ?? [];
-      ir.members = members.map((member) => runtimeValidatorToIR(member));
-      break;
-    }
-  }
-  return ir;
-};
-const shardModeToIR = (shardMode) => {
-  if (shardMode?.kind === "global") {
-    return "global";
-  }
-  if (shardMode?.kind === "shardBy" && typeof shardMode.field === "string") {
-    return { field: shardMode.field, kind: "shardBy" };
-  }
-  return "root";
-};
-const warnDroppedTableFeatures = (builder, bareName) => {
-  const dropped = [];
-  if (builder.relationMap && Object.keys(builder.relationMap).length > 0) {
-    dropped.push("relations");
-  }
-  if (builder.rankIndexes && builder.rankIndexes.length > 0) {
-    dropped.push("rank indexes");
-  }
-  if (builder.vectorIndexes && builder.vectorIndexes.length > 0) {
-    dropped.push("vector indexes");
-  }
-  if (dropped.length > 0) {
-    console.warn(
-      `@lunora/codegen: package schema-extension table "${bareName}" declares ${dropped.join(" + ")}, which are not yet introspected from a node_modules extension — they will be absent from the generated types.`
-    );
-  }
-};
-const runtimeTableToIR = (builder, bareName) => {
-  const shape = builder.shape ?? {};
-  const indexes = (builder.indexes ?? []).map((index) => {
-    return { fields: index.fields, name: index.name, ...index.unique ? { unique: true } : {} };
-  });
-  warnDroppedTableFeatures(builder, bareName);
-  return {
-    ...builder.isExternallyManaged ? { externallyManaged: true } : {},
-    geoIndexes: [],
-    indexes,
-    name: bareName,
-    rankIndexes: [],
-    relations: [],
-    searchIndexes: (builder.searchIndexes ?? []).map((index) => {
-      return {
-        field: index.field,
-        ...index.filterFields ? { filterFields: index.filterFields } : {},
-        name: index.name
-      };
-    }),
-    shape: Object.fromEntries(Object.entries(shape).map(([name, validator]) => [name, runtimeValidatorToIR(validator)])),
-    shardMode: shardModeToIR(builder.shardMode),
-    // Inline vector/rank indexes and relations are not yet introspected from a
-    // package extension; their presence is surfaced via `warnDroppedTableFeatures`.
-    vectorIndexes: []
-  };
-};
-const resolvedExtensionToIR = (value) => {
-  const { key, tables } = value;
-  if (typeof key !== "string" || typeof tables !== "object" || tables === null) {
-    return void 0;
-  }
-  const bareTables = Object.entries(tables).map(([bareName, builder]) => runtimeTableToIR(builder, bareName));
-  const vectorIndexes = value["vectorIndexes"] ?? {};
-  const bareVectorIndexes = Object.entries(vectorIndexes ?? {}).map(([name, index]) => {
-    return {
-      ...index.dimensions === void 0 ? {} : { dimensions: index.dimensions },
-      ...index.field === void 0 ? {} : { field: index.field },
-      ...index.metadata === void 0 ? {} : { metadata: index.metadata },
-      ...index.metric === void 0 ? {} : { metric: index.metric },
-      name,
-      table: index.table ?? ""
-    };
-  });
-  return { bareTables, bareVectorIndexes, key };
-};
-const receiverIdentifierText = (argument) => {
-  if (Node.isIdentifier(argument)) {
-    return argument.getText();
-  }
-  if (Node.isPropertyAccessExpression(argument)) {
-    const receiver = argument.getExpression();
-    return Node.isIdentifier(receiver) ? receiver.getText() : void 0;
-  }
-  return void 0;
-};
-const accessPathOf = (argument) => {
-  const receiverName = receiverIdentifierText(argument);
-  if (receiverName === void 0) {
-    return void 0;
-  }
-  const property = Node.isPropertyAccessExpression(argument) ? argument.getName() : void 0;
-  const propertyPath = property === void 0 ? [] : [property];
-  for (const declaration of argument.getSourceFile().getImportDeclarations()) {
-    const moduleSpecifier = declaration.getModuleSpecifierValue();
-    for (const named of declaration.getNamedImports()) {
-      const localName = named.getAliasNode()?.getText() ?? named.getName();
-      if (localName === receiverName) {
-        return { importedName: named.getName(), moduleSpecifier, propertyPath };
-      }
-    }
-    if (declaration.getDefaultImport()?.getText() === receiverName) {
-      return { importedName: "default", moduleSpecifier, propertyPath };
-    }
-    if (declaration.getNamespaceImport()?.getText() === receiverName && property !== void 0) {
-      return { importedName: property, moduleSpecifier, propertyPath: [] };
-    }
-  }
-  return void 0;
-};
-const readExtensionValue = (module_, access) => {
-  let current = module_[access.importedName];
-  for (const segment of access.propertyPath) {
-    if (typeof current !== "object" || current === null) {
-      return void 0;
-    }
-    current = current[segment];
-  }
-  return current;
-};
-const resolvePackageExtension = (argument, projectRoot) => {
-  const access = accessPathOf(argument);
-  if (!access) {
-    return void 0;
-  }
-  try {
-    const projectRequire = createRequire(join(projectRoot, "noop.cjs"));
-    const resolved = projectRequire.resolve(access.moduleSpecifier);
-    const loadedModule = projectRequire(resolved);
-    const value = readExtensionValue(loadedModule, access);
-    if (typeof value !== "object" || value === null) {
-      return void 0;
-    }
-    return resolvedExtensionToIR(value);
-  } catch {
-    return void 0;
-  }
-};
-
-const VECTOR_METRICS = /* @__PURE__ */ new Set(["cosine", "dot-product", "euclidean"]);
-const ON_DELETE_ACTIONS = /* @__PURE__ */ new Set(["cascade", "restrict", "set null"]);
-const RESERVED_TABLE_NAMES = /* @__PURE__ */ new Set(["delete", "get", "insert", "normalizeId", "patch", "query", "replace", "system"]);
-const assertTableNameAllowed = (name, node) => {
-  if (RESERVED_TABLE_NAMES.has(name)) {
-    throw diagnosticAt(
-      node,
-      `table name "${name}" is reserved — it collides with a \`ctx.db\` member (one of ${[...RESERVED_TABLE_NAMES].map((reserved) => `"${reserved}"`).join(", ")}). Rename the table.`
-    );
-  }
-};
-const getStringProperty = (object, key) => {
-  const property = object.getProperty(key);
-  if (property && Node.isPropertyAssignment(property)) {
-    const initializer = property.getInitializer();
-    if (initializer && Node.isStringLiteral(initializer)) {
-      return initializer.getLiteralText();
-    }
-  }
-  return void 0;
-};
-const getNumberProperty = (object, key) => {
-  const property = object.getProperty(key);
-  if (property && Node.isPropertyAssignment(property)) {
-    const initializer = property.getInitializer();
-    if (initializer && Node.isNumericLiteral(initializer)) {
-      return Number(initializer.getLiteralText());
-    }
-  }
-  return void 0;
-};
-const getStringArrayProperty = (object, key) => {
-  const property = object.getProperty(key);
-  if (property && Node.isPropertyAssignment(property)) {
-    const initializer = property.getInitializer();
-    if (initializer && Node.isArrayLiteralExpression(initializer)) {
-      return initializer.getElements().filter((element) => Node.isStringLiteral(element)).map((element) => element.getLiteralText());
-    }
-  }
-  return void 0;
-};
-const asMetric = (value) => value && VECTOR_METRICS.has(value) ? value : void 0;
-const asOnDelete = (value) => value && ON_DELETE_ACTIONS.has(value) ? value : void 0;
-const relationsObjectBody = (argument) => {
-  if (!Node.isArrowFunction(argument)) {
-    return void 0;
-  }
-  let body = argument.getBody();
-  if (Node.isParenthesizedExpression(body)) {
-    body = body.getExpression();
-  } else if (Node.isBlock(body)) {
-    const returnStatement = body.getStatements().find((statement) => Node.isReturnStatement(statement));
-    body = returnStatement && Node.isReturnStatement(returnStatement) ? returnStatement.getExpression() ?? body : body;
-  }
-  return Node.isObjectLiteralExpression(body) ? body : void 0;
-};
-const relationFromProperty = (property) => {
-  if (!Node.isPropertyAssignment(property)) {
-    return void 0;
-  }
-  const initializer = property.getInitializer();
-  if (!initializer || !Node.isCallExpression(initializer)) {
-    return void 0;
-  }
-  const callee = initializer.getExpression();
-  if (!Node.isPropertyAccessExpression(callee)) {
-    return void 0;
-  }
-  const method = callee.getName();
-  if (method !== "one" && method !== "many") {
-    return void 0;
-  }
-  const [tableArgument, optionsExpression] = initializer.getArguments();
-  const table = tableArgument && Node.isStringLiteral(tableArgument) ? tableArgument.getLiteralText() : "_unknown_";
-  let field = "_unknown_";
-  let references = "_id";
-  let onDelete;
-  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
-    field = getStringProperty(optionsExpression, "field") ?? field;
-    references = getStringProperty(optionsExpression, "references") ?? references;
-    onDelete = method === "one" ? asOnDelete(getStringProperty(optionsExpression, "onDelete")) : void 0;
-  }
-  return { field, kind: method, name: property.getName(), onDelete, references, table };
-};
-const parseRelations = (argument) => {
-  const body = relationsObjectBody(argument);
-  if (!body) {
-    return [];
-  }
-  const relations = [];
-  for (const property of body.getProperties()) {
-    const relation = relationFromProperty(property);
-    if (relation) {
-      relations.push(relation);
-    }
-  }
-  return relations;
-};
-const indexNameOf = (nameArgument) => nameArgument && Node.isStringLiteral(nameArgument) ? nameArgument.getLiteralText() : "_unnamed_";
-const parseIndexCall = (args) => {
-  const [indexName, fieldsExpression, optionsExpression] = args;
-  let unique = false;
-  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
-    const property = optionsExpression.getProperty("unique");
-    if (property && Node.isPropertyAssignment(property)) {
-      const initializer = property.getInitializer();
-      if (initializer && !Node.isTrueLiteral(initializer) && !Node.isFalseLiteral(initializer)) {
-        throw diagnosticAt(initializer, `\`unique\` must be a literal \`true\` or \`false\`, got ${JSON.stringify(initializer.getText())}`);
-      }
-      unique = initializer ? Node.isTrueLiteral(initializer) : false;
-    }
-  }
-  const fields = fieldsExpression && Node.isArrayLiteralExpression(fieldsExpression) ? fieldsExpression.getElements().filter((element) => Node.isStringLiteral(element)).map((element) => element.getLiteralText()) : [];
-  return { fields, name: indexNameOf(indexName), unique };
-};
-const parseSearchIndexCall = (args) => {
-  const [indexName, optionsExpression] = args;
-  let field = "_unknown_";
-  let filterFields;
-  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
-    field = getStringProperty(optionsExpression, "field") ?? field;
-    filterFields = getStringArrayProperty(optionsExpression, "filterFields");
-  }
-  return { field, filterFields, name: indexNameOf(indexName) };
-};
-const parseGeoIndexCall = (args) => {
-  const [indexName, optionsExpression] = args;
-  let field = "_unknown_";
-  let precision;
-  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
-    field = getStringProperty(optionsExpression, "field") ?? field;
-    precision = getNumberProperty(optionsExpression, "precision");
-  }
-  return { field, name: indexNameOf(indexName), precision };
-};
-const parseTtlCall = (args) => {
-  const [fieldArgument, optionsExpression] = args;
-  const field = fieldArgument && Node.isStringLiteral(fieldArgument) ? fieldArgument.getLiteralText() : "_unknown_";
-  let after;
-  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
-    after = getNumberProperty(optionsExpression, "after");
-  }
-  return { after, field };
-};
-const rankSortKeyFromElement = (element) => {
-  if (!Node.isObjectLiteralExpression(element)) {
-    return void 0;
-  }
-  const field = getStringProperty(element, "field");
-  if (field === void 0) {
-    return void 0;
-  }
-  const direction = getStringProperty(element, "direction");
-  return { direction: direction === "desc" ? "desc" : "asc", field };
-};
-const parseRankIndexCall = (args) => {
-  const [indexName, optionsExpression] = args;
-  let sortBy = [];
-  let partitionBy;
-  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
-    const sortByProperty = optionsExpression.getProperty("sortBy");
-    if (sortByProperty && Node.isPropertyAssignment(sortByProperty)) {
-      const initializer = sortByProperty.getInitializer();
-      if (initializer && Node.isArrayLiteralExpression(initializer)) {
-        sortBy = initializer.getElements().map((element) => rankSortKeyFromElement(element)).filter((key) => key !== void 0);
-      }
-    }
-    partitionBy = getStringArrayProperty(optionsExpression, "partitionBy");
-  }
-  return { name: indexNameOf(indexName), partitionBy, sortBy };
-};
-const parseVectorizeCall = (args, table) => {
-  const [fieldArgument, optionsExpression] = args;
-  const field = fieldArgument && Node.isStringLiteral(fieldArgument) ? fieldArgument.getLiteralText() : "_unknown_";
-  if (!optionsExpression || !Node.isObjectLiteralExpression(optionsExpression)) {
-    return void 0;
-  }
-  return {
-    dimensions: getNumberProperty(optionsExpression, "dimensions"),
-    field,
-    metadata: getStringArrayProperty(optionsExpression, "metadata"),
-    metric: asMetric(getStringProperty(optionsExpression, "metric")),
-    name: getStringProperty(optionsExpression, "index") ?? "_unnamed_",
-    table
-  };
-};
-const parseGlobalBackend = (args) => {
-  const optionsExpression = args[0];
-  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
-    const backend = getStringProperty(optionsExpression, "backend");
-    if (backend === "hyperdrive") {
-      return "hyperdrive";
-    }
-  }
-  return "d1";
-};
-const softDeleteFieldOf = (optionsArgument) => {
-  if (optionsArgument && Node.isObjectLiteralExpression(optionsArgument)) {
-    const fieldProperty = optionsArgument.getProperty("field");
-    if (fieldProperty && Node.isPropertyAssignment(fieldProperty)) {
-      const initializer = fieldProperty.getInitializer();
-      if (initializer && Node.isStringLiteral(initializer)) {
-        return initializer.getLiteralText();
-      }
-    }
-  }
-  return "deletedAt";
-};
-const stringPropertyOf = (object, property) => {
-  const node = object.getProperty(property);
-  if (node && Node.isPropertyAssignment(node)) {
-    const initializer = node.getInitializer();
-    if (initializer && Node.isStringLiteral(initializer)) {
-      return initializer.getLiteralText();
-    }
-  }
-  return void 0;
-};
-const stringArrayPropertyOf = (object, property) => {
-  const node = object.getProperty(property);
-  if (node && Node.isPropertyAssignment(node)) {
-    const initializer = node.getInitializer();
-    if (initializer && Node.isArrayLiteralExpression(initializer)) {
-      const items = initializer.getElements().filter((element) => Node.isStringLiteral(element)).map((element) => element.getLiteralText());
-      return items.length > 0 ? items : void 0;
-    }
-  }
-  return void 0;
-};
-const parseSourceCall = (args) => {
-  const first = args[0];
-  if (!first || !Node.isObjectLiteralExpression(first)) {
-    return { binding: "", hasTenantBy: false, unanalyzable: true };
-  }
-  return {
-    binding: stringPropertyOf(first, "binding") ?? "",
-    columns: stringArrayPropertyOf(first, "columns"),
-    hasReconcile: first.getProperty("reconcileEveryMs") !== void 0,
-    hasSoftDelete: first.getProperty("softDeleteColumn") !== void 0,
-    hasTenantBy: first.getProperty("tenantBy") !== void 0,
-    idColumn: stringPropertyOf(first, "idColumn"),
-    mode: stringPropertyOf(first, "mode"),
-    query: stringPropertyOf(first, "query")
-  };
-};
-const applyTableMethod = (accumulator, method, args, name) => {
-  switch (method) {
-    case "externallyManaged": {
-      accumulator.externallyManaged = true;
-      break;
-    }
-    case "geoIndex": {
-      accumulator.geoIndexes.push(parseGeoIndexCall(args));
-      break;
-    }
-    case "global": {
-      accumulator.shardMode = "global";
-      accumulator.globalBackend = parseGlobalBackend(args);
-      break;
-    }
-    case "index": {
-      accumulator.indexes.push(parseIndexCall(args));
-      break;
-    }
-    case "public": {
-      accumulator.isPublic = true;
-      break;
-    }
-    case "rankIndex": {
-      accumulator.rankIndexes.push(parseRankIndexCall(args));
-      break;
-    }
-    case "relations": {
-      const builder = args[0];
-      if (builder) {
-        accumulator.relations.push(...parseRelations(builder));
-      }
-      break;
-    }
-    case "searchIndex": {
-      accumulator.searchIndexes.push(parseSearchIndexCall(args));
-      break;
-    }
-    case "shardBy": {
-      const field = args[0];
-      accumulator.shardMode = { field: field && Node.isStringLiteral(field) ? field.getLiteralText() : "_unknown_", kind: "shardBy" };
-      break;
-    }
-    case "softDelete": {
-      accumulator.softDelete = { field: softDeleteFieldOf(args[0]) };
-      break;
-    }
-    case "source": {
-      accumulator.externalSource = parseSourceCall(args);
-      accumulator.externallyManaged = true;
-      break;
-    }
-    case "ttl": {
-      accumulator.ttl = parseTtlCall(args);
-      break;
-    }
-    case "vectorize": {
-      const vectorIndex = parseVectorizeCall(args, name);
-      if (vectorIndex) {
-        accumulator.vectorIndexes.push(vectorIndex);
-      }
-      break;
-    }
-  }
-};
-const parseTableBuilder = (expression, name) => {
-  const accumulator = {
-    externallyManaged: false,
-    geoIndexes: [],
-    indexes: [],
-    isPublic: false,
-    rankIndexes: [],
-    relations: [],
-    searchIndexes: [],
-    shardMode: "root",
-    vectorIndexes: []
-  };
-  let shape = {};
-  let current = expression;
-  while (Node.isCallExpression(current)) {
-    const callee = current.getExpression();
-    const args = current.getArguments();
-    if (Node.isPropertyAccessExpression(callee)) {
-      applyTableMethod(accumulator, callee.getName(), args, name);
-      current = callee.getExpression();
-    } else if (Node.isIdentifier(callee) && callee.getText() === "defineTable") {
-      const first = args[0];
-      if (first && Node.isObjectLiteralExpression(first)) {
-        shape = parseObjectShape(first);
-      }
-      break;
-    } else {
-      break;
-    }
-  }
-  if (accumulator.softDelete && !(accumulator.softDelete.field in shape)) {
-    shape = { ...shape, [accumulator.softDelete.field]: { inner: { kind: "number" }, kind: "optional" } };
-  }
-  return {
-    externallyManaged: accumulator.externallyManaged,
-    externalSource: accumulator.externalSource,
-    geoIndexes: accumulator.geoIndexes,
-    globalBackend: accumulator.shardMode === "global" ? accumulator.globalBackend ?? "d1" : void 0,
-    indexes: accumulator.indexes,
-    isPublic: accumulator.isPublic,
-    name,
-    rankIndexes: accumulator.rankIndexes,
-    relations: accumulator.relations,
-    searchIndexes: accumulator.searchIndexes,
-    shape,
-    shardMode: accumulator.shardMode,
-    softDelete: accumulator.softDelete,
-    ttl: accumulator.ttl,
-    vectorIndexes: accumulator.vectorIndexes
-  };
-};
-const sourceTableOf = (optionsExpression) => {
-  const sourceProperty = optionsExpression.getProperty("source");
-  if (sourceProperty && Node.isPropertyAssignment(sourceProperty)) {
-    const sourceInitializer = sourceProperty.getInitializer();
-    if (sourceInitializer && Node.isObjectLiteralExpression(sourceInitializer)) {
-      return getStringProperty(sourceInitializer, "table") ?? "_unknown_";
-    }
-  }
-  return "_unknown_";
-};
-const standaloneVectorIndexFromProperty = (property) => {
-  if (!Node.isPropertyAssignment(property)) {
-    return void 0;
-  }
-  const initializer = property.getInitializer();
-  if (!initializer || !Node.isCallExpression(initializer)) {
-    return void 0;
-  }
-  const callee = initializer.getExpression();
-  if (!Node.isIdentifier(callee) || callee.getText() !== "defineVectorIndex") {
-    return void 0;
-  }
-  const optionsExpression = initializer.getArguments()[0];
-  if (!optionsExpression || !Node.isObjectLiteralExpression(optionsExpression)) {
-    return void 0;
-  }
-  const nameNode = property.getNameNode();
-  const indexName = Node.isStringLiteral(nameNode) ? nameNode.getLiteralText() : nameNode.getText();
-  return {
-    dimensions: getNumberProperty(optionsExpression, "dimensions"),
-    metric: asMetric(getStringProperty(optionsExpression, "metric")),
-    name: indexName,
-    table: sourceTableOf(optionsExpression)
-  };
-};
-const parseStandaloneVectorIndexes = (object) => {
-  const result = [];
-  for (const property of object.getProperties()) {
-    const index = standaloneVectorIndexFromProperty(property);
-    if (index) {
-      result.push(index);
-    }
-  }
-  return result;
-};
-const prefixTableName = (key, bareName) => `${key}_${bareName}`;
-const rewriteReference = (target, key, bareNames) => bareNames.has(target) ? prefixTableName(key, target) : target;
-const namespaceExtensionTable = (table, key, bareNames) => {
-  const ownPrefixed = prefixTableName(key, table.name);
-  return {
-    ...table,
-    name: ownPrefixed,
-    relations: table.relations.map((relation) => {
-      return { ...relation, table: rewriteReference(relation.table, key, bareNames) };
-    }),
-    // Inline `.vectorize()` stamps `table` with the bare owner name, so it
-    // is always one of `bareNames` and resolves to `ownPrefixed`.
-    vectorIndexes: table.vectorIndexes.map((index) => {
-      return { ...index, table: rewriteReference(index.table, key, bareNames) };
-    })
-  };
-};
-const declarationInitializer = (declaration) => {
-  if (Node.isVariableDeclaration(declaration) || Node.isPropertyAssignment(declaration)) {
-    return declaration.getInitializer();
-  }
-  if (Node.isShorthandPropertyAssignment(declaration)) {
-    return declaration.getNameNode();
-  }
-  return void 0;
-};
-const objectPropertyInitializer = (objectLiteral, name) => {
-  const property = objectLiteral.getProperty(name);
-  if (property && Node.isPropertyAssignment(property)) {
-    return property.getInitializer();
-  }
-  return void 0;
-};
-const isInlineExtensionCall = (argument) => {
-  if (!Node.isCallExpression(argument)) {
-    return false;
-  }
-  const callee = argument.getExpression();
-  return Node.isIdentifier(callee) && callee.getText() === "defineSchemaExtension";
-};
-const extensionTargetIdentifier = (argument) => {
-  if (Node.isIdentifier(argument)) {
-    return argument;
-  }
-  if (Node.isPropertyAccessExpression(argument)) {
-    const receiver = argument.getExpression();
-    return Node.isIdentifier(receiver) ? receiver : void 0;
-  }
-  return void 0;
-};
-const pluginConfigObject = (expression) => {
-  if (Node.isObjectLiteralExpression(expression)) {
-    return expression;
-  }
-  if (Node.isCallExpression(expression)) {
-    const callee = expression.getExpression();
-    let name;
-    if (Node.isIdentifier(callee)) {
-      name = callee.getText();
-    } else if (Node.isPropertyAccessExpression(callee)) {
-      name = callee.getName();
-    }
-    if (name === "definePlugin") {
-      const configArgument = expression.getArguments()[1];
-      return configArgument && Node.isObjectLiteralExpression(configArgument) ? configArgument : void 0;
-    }
-  }
-  return void 0;
-};
-const nextExpressionFromDeclaration = (declaration, argument) => {
-  const initializer = declarationInitializer(declaration);
-  if (!initializer) {
-    return void 0;
-  }
-  if (Node.isPropertyAccessExpression(argument)) {
-    const configObject = pluginConfigObject(initializer);
-    return configObject ? objectPropertyInitializer(configObject, argument.getName()) : void 0;
-  }
-  return initializer;
-};
-const resolveSchemaExtensionCall = (argument) => {
-  let current = argument;
-  let hops = 0;
-  while (current && hops < 32) {
-    hops += 1;
-    if (isInlineExtensionCall(current)) {
-      return current;
-    }
-    const target = extensionTargetIdentifier(current);
-    const symbol = target && Node.isIdentifier(target) ? target.getSymbol() : void 0;
-    const declarations = symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
-    const first = declarations[0];
-    if (!first) {
-      return void 0;
-    }
-    const declarationFile = first.getSourceFile();
-    if (declarationFile.isInNodeModules() || declarationFile.isDeclarationFile()) {
-      return void 0;
-    }
-    current = nextExpressionFromDeclaration(first, current);
-  }
-  return void 0;
-};
-const extensionPartsOf = (call) => {
-  const [keyArgument, optionsArgument] = call.getArguments();
-  if (!keyArgument || !Node.isStringLiteral(keyArgument)) {
-    return void 0;
-  }
-  if (!optionsArgument || !Node.isObjectLiteralExpression(optionsArgument)) {
-    return void 0;
-  }
-  return { key: keyArgument.getLiteralText(), options: optionsArgument };
-};
-const parseExtensionTables = (options) => {
-  const tablesProperty = options.getProperty("tables");
-  if (!tablesProperty || !Node.isPropertyAssignment(tablesProperty)) {
-    return [];
-  }
-  const tablesObject = tablesProperty.getInitializer();
-  if (!tablesObject || !Node.isObjectLiteralExpression(tablesObject)) {
-    return [];
-  }
-  const tables = [];
-  for (const property of tablesObject.getProperties()) {
-    if (!Node.isPropertyAssignment(property)) {
-      continue;
-    }
-    const initializer = property.getInitializer();
-    if (!initializer) {
-      continue;
-    }
-    tables.push(parseTableBuilder(initializer, property.getName()));
-  }
-  return tables;
-};
-const parseExtensionVectorIndexes = (options) => {
-  const property = options.getProperty("vectorIndexes");
-  if (!property || !Node.isPropertyAssignment(property)) {
-    return [];
-  }
-  const object = property.getInitializer();
-  if (!object || !Node.isObjectLiteralExpression(object)) {
-    return [];
-  }
-  return parseStandaloneVectorIndexes(object);
-};
-const namespaceExtension = (key, bareTables, bareVectorIndexes) => {
-  const bareNames = new Set(bareTables.map((table) => table.name));
-  const tables = bareTables.map((table) => namespaceExtensionTable(table, key, bareNames));
-  const vectorIndexes = bareVectorIndexes.map((index) => {
-    return { ...index, name: prefixTableName(key, index.name), table: rewriteReference(index.table, key, bareNames) };
-  });
-  return { tables, vectorIndexes };
-};
-const mergeExtension = (key, options) => namespaceExtension(key, parseExtensionTables(options), parseExtensionVectorIndexes(options));
-const mergeExtendCall = (extendCall, projectRoot) => {
-  const extendArgument = extendCall.getArguments()[0];
-  if (!extendArgument) {
-    return void 0;
-  }
-  const resolved = resolveSchemaExtensionCall(extendArgument);
-  if (!resolved) {
-    if (projectRoot !== void 0) {
-      const fromPackage = resolvePackageExtension(extendArgument, projectRoot);
-      if (fromPackage) {
-        return namespaceExtension(fromPackage.key, fromPackage.bareTables, fromPackage.bareVectorIndexes);
-      }
-    }
-    console.warn(
-      `@lunora/codegen: skipping \`.extend(${extendArgument.getText()})\` — its \`defineSchemaExtension(...)\` could not be resolved from local sources, and ${projectRoot === void 0 ? "no project root was available to resolve the package" : "the package could not be imported/introspected"}. Extension tables will be absent from the generated types.`
-    );
-    return void 0;
-  }
-  const parts = extensionPartsOf(resolved);
-  if (!parts) {
-    console.warn(`@lunora/codegen: skipping \`.extend(...)\` — \`defineSchemaExtension\` requires a string \`key\` and an options object literal.`);
-    return void 0;
-  }
-  return mergeExtension(parts.key, parts.options);
-};
-const extendCallsOf = (defineSchemaCall) => {
-  const calls = [];
-  let current = defineSchemaCall;
-  for (; ; ) {
-    const parent = current.getParent();
-    if (!parent || !Node.isPropertyAccessExpression(parent)) {
-      break;
-    }
-    const callParent = parent.getParent();
-    if (!callParent || !Node.isCallExpression(callParent)) {
-      break;
-    }
-    if (parent.getName() === "extend") {
-      calls.push(callParent);
-    }
-    current = callParent;
-  }
-  return calls;
-};
-const chainedStringLiteralArgument = (defineSchemaCall, methodName, noun, allowed, expected) => {
-  let current = defineSchemaCall;
-  for (; ; ) {
-    const parent = current.getParent();
-    if (!parent || !Node.isPropertyAccessExpression(parent)) {
-      break;
-    }
-    const callParent = parent.getParent();
-    if (!callParent || !Node.isCallExpression(callParent)) {
-      break;
-    }
-    if (parent.getName() === methodName) {
-      const argument = callParent.getArguments()[0];
-      if (!argument || !Node.isStringLiteral(argument)) {
-        throw diagnosticAt(callParent, `\`.${methodName}(...)\` expects a string literal (${expected})`);
-      }
-      const value = argument.getLiteralText();
-      if (!allowed.has(value)) {
-        throw diagnosticAt(argument, `unknown ${noun} ${JSON.stringify(value)} — expected ${expected}`);
-      }
-      return value;
-    }
-    current = callParent;
-  }
-  return void 0;
-};
-const JURISDICTIONS = /* @__PURE__ */ new Set(["eu", "fedramp", "us"]);
-const jurisdictionOf = (defineSchemaCall) => chainedStringLiteralArgument(defineSchemaCall, "jurisdiction", "jurisdiction", JURISDICTIONS, '"eu", "us", or "fedramp"');
-const RLS_MODES = /* @__PURE__ */ new Set(["required"]);
-const rlsModeOf = (defineSchemaCall) => chainedStringLiteralArgument(defineSchemaCall, "rls", "rls mode", RLS_MODES, '"required"');
-const parseBaseTables = (object) => {
-  const tables = [];
-  for (const property of object.getProperties()) {
-    if (!Node.isPropertyAssignment(property)) {
-      continue;
-    }
-    const initializer = property.getInitializer();
-    if (initializer) {
-      const name = property.getName();
-      assertTableNameAllowed(name, property.getNameNode());
-      tables.push(parseTableBuilder(initializer, name));
-    }
-  }
-  return tables;
-};
-const applyExtensions = (defineSchemaCall, tables, projectRoot) => {
-  const existingTableNames = new Set(tables.map((table) => table.name));
-  const vectorIndexes = [];
-  for (const extendCall of extendCallsOf(defineSchemaCall)) {
-    const merged = mergeExtendCall(extendCall, projectRoot);
-    if (!merged) {
-      continue;
-    }
-    for (const table of merged.tables) {
-      if (existingTableNames.has(table.name)) {
-        throw diagnosticAt(
-          extendCall,
-          `defineSchema(...).extend(...): table "${table.name}" already exists — another extension with the same key already contributed it.`
-        );
-      }
-      existingTableNames.add(table.name);
-      tables.push(table);
-    }
-    vectorIndexes.push(...merged.vectorIndexes);
-  }
-  return vectorIndexes;
-};
-const discoverSchema = (project, schemaPath, projectRoot) => {
-  const file = project.addSourceFileAtPath(schemaPath);
-  const defineSchemaCall = file.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => {
-    const callee = call.getExpression();
-    return Node.isIdentifier(callee) && callee.getText() === "defineSchema";
-  });
-  if (!defineSchemaCall) {
-    throw new LunoraError("INTERNAL", `defineSchema() not found in ${schemaPath}`);
-  }
-  const argument = defineSchemaCall.getArguments()[0];
-  if (!argument || !Node.isObjectLiteralExpression(argument)) {
-    throw diagnosticAt(defineSchemaCall, "defineSchema() expects an object literal");
-  }
-  const tables = parseBaseTables(argument);
-  const standaloneArgument = defineSchemaCall.getArguments()[1];
-  const standaloneVectorIndexes = standaloneArgument && Node.isObjectLiteralExpression(standaloneArgument) ? parseStandaloneVectorIndexes(standaloneArgument) : [];
-  const extensionStandaloneVectorIndexes = applyExtensions(defineSchemaCall, tables, projectRoot);
-  const vectorIndexes = [...tables.flatMap((table) => table.vectorIndexes), ...standaloneVectorIndexes, ...extensionStandaloneVectorIndexes];
-  return { jurisdiction: jurisdictionOf(defineSchemaCall), rlsMode: rlsModeOf(defineSchemaCall), tables, vectorIndexes };
-};
-
-export { discoverSchema as default };