@lunora/codegen 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/packem_shared/{discoverMigrations-Doj_-BAA.mjs → discoverMigrations-CdKtMlBc.mjs}

@@ -1,6 +1,7 @@
 import { relative, sep } from 'node:path';
 import { SyntaxKind, Node } from 'ts-morph';
-import { listLunoraSourceFiles } from './discoverFunctions-DEgAcRuD.mjs';
+import { diagnosticAt } from './CodegenDiagnosticError-DyQ5FwkM.mjs';
+import { listLunoraSourceFiles } from './discoverFunctions-CZ91aenA.mjs';
 
 const TS_EXTENSION_RE = /\.ts$/u;
 const isDefineMigration = (identifier) => {
@@ -43,9 +44,14 @@ const migrationFromDeclaration = (declaration, relativePath) => {
   const id = stringProperty(argument, "id");
   const exportName = declaration.getName();
   if (id === void 0 || id.trim() === "") {
-    throw Object.assign(
-      new Error(`Migration "${exportName}" in "${relativePath}" must declare \`id\` as a non-empty string literal so codegen can key the registry.`),
-      { code: "MIGRATION_ID_NOT_STATIC", name: "LunoraError", status: 500 }
+    throw diagnosticAt(
+      argument,
+      `Migration "${exportName}" in "${relativePath}" must declare \`id\` as a non-empty string literal so codegen can key the registry.`,
+      {
+        code: "MIGRATION_ID_NOT_STATIC",
+        name: "LunoraError",
+        status: 500
+      }
     );
   }
   return { exportName, filePath: relativePath, id, table: stringProperty(argument, "table") ?? "" };

package/dist/packem_shared/{discoverNondeterministicCalls-4KiPQxQU.mjs → discoverNondeterministicCalls-C_PrQPkA.mjs}

@@ -1,5 +1,5 @@
 import { Node, SyntaxKind } from 'ts-morph';
-import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-CZ91aenA.mjs';
 
 const PROPERTY_CALLS = {
   "crypto.getRandomValues": "crypto.getRandomValues",

package/dist/packem_shared/{discoverQueries-BkIi0dBD.mjs → discoverQueries-B8W9UPrt.mjs}

@@ -1,5 +1,5 @@
 import { SyntaxKind, Node } from 'ts-morph';
-import { listLunoraSourceFiles, lunoraRelativePath } from './discoverFunctions-DEgAcRuD.mjs';
+import { listLunoraSourceFiles, lunoraRelativePath } from './discoverFunctions-CZ91aenA.mjs';
 
 const INDEX_METHODS = /* @__PURE__ */ new Set(["withIndex", "withSearchIndex"]);
 const isDatabaseQueryCall = (call) => {

package/dist/packem_shared/{discoverR2sqlCalls-BpDqvcUn.mjs → discoverR2sqlCalls-Bm7Rfnf4.mjs}

@@ -1,5 +1,5 @@
 import { Node, SyntaxKind } from 'ts-morph';
-import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-CZ91aenA.mjs';
 
 const handlerOf = (call, receiver) => {
   if (receiver) {

package/dist/packem_shared/{discoverRlsMetadata-DpRB1HMe.mjs → discoverRlsMetadata-B4GL4ZKm.mjs}

@@ -1,5 +1,5 @@
 import { Node, SyntaxKind } from 'ts-morph';
-import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-CZ91aenA.mjs';
 
 const isRlsCall = (node) => {
   if (!Node.isCallExpression(node)) {

package/dist/packem_shared/{discoverSchema-BBulgGbH.mjs → discoverSchema-DFWVgU5o.mjs}

@@ -1,6 +1,213 @@
-import { SyntaxKind, Node } from 'ts-morph';
-import { diagnosticAt } from './CodegenDiagnosticError-54jWDxA9.mjs';
-import { a as parseObjectShape } from './parse-validator-tuQtHrsr.mjs';
+import { LunoraError } from '@lunora/errors';
+import { Node, SyntaxKind } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-DyQ5FwkM.mjs';
+import { a as parseObjectShape } from './parse-validator-BSJo1HGP.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 } : {},
+    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"]);
@@ -179,6 +386,54 @@ const parseGlobalBackend = (args) => {
   }
   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,
+    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": {
@@ -194,6 +449,10 @@ const applyTableMethod = (accumulator, method, args, name) => {
       accumulator.indexes.push(parseIndexCall(args));
       break;
     }
+    case "public": {
+      accumulator.isPublic = true;
+      break;
+    }
     case "rankIndex": {
       accumulator.rankIndexes.push(parseRankIndexCall(args));
       break;
@@ -214,6 +473,15 @@ const applyTableMethod = (accumulator, method, args, name) => {
       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 "vectorize": {
       const vectorIndex = parseVectorizeCall(args, name);
       if (vectorIndex) {
@@ -227,6 +495,7 @@ const parseTableBuilder = (expression, name) => {
   const accumulator = {
     externallyManaged: false,
     indexes: [],
+    isPublic: false,
     rankIndexes: [],
     relations: [],
     searchIndexes: [],
@@ -251,16 +520,22 @@ const parseTableBuilder = (expression, name) => {
       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,
     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,
     vectorIndexes: accumulator.vectorIndexes
   };
 };
@@ -354,7 +629,27 @@ const extensionTargetIdentifier = (argument) => {
     return argument;
   }
   if (Node.isPropertyAccessExpression(argument)) {
-    return argument.getNameNode();
+    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;
 };
@@ -363,8 +658,9 @@ const nextExpressionFromDeclaration = (declaration, argument) => {
   if (!initializer) {
     return void 0;
   }
-  if (Node.isPropertyAccessExpression(argument) && Node.isObjectLiteralExpression(initializer)) {
-    return objectPropertyInitializer(initializer, argument.getName());
+  if (Node.isPropertyAccessExpression(argument)) {
+    const configObject = pluginConfigObject(initializer);
+    return configObject ? objectPropertyInitializer(configObject, argument.getName()) : void 0;
   }
   return initializer;
 };
@@ -434,24 +730,30 @@ const parseExtensionVectorIndexes = (options) => {
   }
   return parseStandaloneVectorIndexes(object);
 };
-const mergeExtension = (key, options) => {
-  const bareTables = parseExtensionTables(options);
+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 = parseExtensionVectorIndexes(options).map((index) => {
+  const vectorIndexes = bareVectorIndexes.map((index) => {
     return { ...index, name: prefixTableName(key, index.name), table: rewriteReference(index.table, key, bareNames) };
   });
   return { tables, vectorIndexes };
 };
-const mergeExtendCall = (extendCall) => {
+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(...)\` definition could not be resolved from local sources (cross-package node_modules/.d.ts resolution is a deferred phase). Extension tables will be absent from the generated types.`
+      `@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;
   }
@@ -481,6 +783,36 @@ const extendCallsOf = (defineSchemaCall) => {
   }
   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()) {
@@ -496,11 +828,11 @@ const parseBaseTables = (object) => {
   }
   return tables;
 };
-const applyExtensions = (defineSchemaCall, 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);
+    const merged = mergeExtendCall(extendCall, projectRoot);
     if (!merged) {
       continue;
     }
@@ -518,14 +850,14 @@ const applyExtensions = (defineSchemaCall, tables) => {
   }
   return vectorIndexes;
 };
-const discoverSchema = (project, schemaPath) => {
+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 Error(`defineSchema() not found in ${schemaPath}`);
+    throw new LunoraError("INTERNAL", `defineSchema() not found in ${schemaPath}`);
   }
   const argument = defineSchemaCall.getArguments()[0];
   if (!argument || !Node.isObjectLiteralExpression(argument)) {
@@ -534,9 +866,9 @@ const discoverSchema = (project, schemaPath) => {
   const tables = parseBaseTables(argument);
   const standaloneArgument = defineSchemaCall.getArguments()[1];
   const standaloneVectorIndexes = standaloneArgument && Node.isObjectLiteralExpression(standaloneArgument) ? parseStandaloneVectorIndexes(standaloneArgument) : [];
-  const extensionStandaloneVectorIndexes = applyExtensions(defineSchemaCall, tables);
+  const extensionStandaloneVectorIndexes = applyExtensions(defineSchemaCall, tables, projectRoot);
   const vectorIndexes = [...tables.flatMap((table) => table.vectorIndexes), ...standaloneVectorIndexes, ...extensionStandaloneVectorIndexes];
-  return { tables, vectorIndexes };
+  return { jurisdiction: jurisdictionOf(defineSchemaCall), rlsMode: rlsModeOf(defineSchemaCall), tables, vectorIndexes };
 };
 
 export { discoverSchema as default };

package/dist/packem_shared/{discoverStorageRulesMetadata-DAqJUxUv.mjs → discoverStorageRulesMetadata-nosjYcvN.mjs}

@@ -1,5 +1,5 @@
 import { Node } from 'ts-morph';
-import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-CZ91aenA.mjs';
 
 const STORAGE_OPERATIONS = /* @__PURE__ */ new Set(["delete", "list", "read", "write"]);
 const isStorageRulesCall = (node) => {