@lunora/codegen 0.0.0 → 1.0.0-alpha.2

package/dist/index.mjs

@@ -0,0 +1,28 @@
+export { formatAdvisories, lintSchema } from './packem_shared/lintSchema-DicbOHvH.mjs';
+export { CodegenDiagnosticError, diagnosticAt } from './packem_shared/CodegenDiagnosticError-54jWDxA9.mjs';
+export { default as discoverAuthApiCalls } from './packem_shared/discoverAuthApiCalls-C35R6z0T.mjs';
+export { CONTAINERS_FILENAME, discoverContainers } from './packem_shared/CONTAINERS_FILENAME-0K-pjNb8.mjs';
+export { default as discoverCrons } from './packem_shared/discoverCrons-BL6iGuJ3.mjs';
+export { discoverFunctions } from './packem_shared/discoverFunctions-DEgAcRuD.mjs';
+export { default as discoverHttpRoutes } from './packem_shared/discoverHttpRoutes-C978pBiG.mjs';
+export { default as discoverInserts } from './packem_shared/discoverInserts-CRQdXvHO.mjs';
+export { default as discoverMaskProcedures } from './packem_shared/discoverMaskProcedures-B64zA740.mjs';
+export { default as discoverMigrations } from './packem_shared/discoverMigrations-Doj_-BAA.mjs';
+export { default as discoverNondeterministicCalls } from './packem_shared/discoverNondeterministicCalls-4KiPQxQU.mjs';
+export { default as discoverQueries } from './packem_shared/discoverQueries-BkIi0dBD.mjs';
+export { discoverRlsMetadata, default as discoverRlsProcedures } from './packem_shared/discoverRlsMetadata-DpRB1HMe.mjs';
+export { default as discoverSchema } from './packem_shared/discoverSchema-BBulgGbH.mjs';
+export { default as discoverStorageRulesMetadata } from './packem_shared/discoverStorageRulesMetadata-DAqJUxUv.mjs';
+export { WORKFLOWS_FILENAME, discoverWorkflows } from './packem_shared/discoverWorkflows-DRDQdhfq.mjs';
+export { GENERATED_HEADER, emitApi, emitContainers, emitCrons, emitDataModel, emitDrizzleSchema, emitFunctions, emitServer, emitShard, emitVectors, emitWorkflows, emitWranglerCronTriggers } from './packem_shared/emitApi-hRVC-kE7.mjs';
+export { emitApp } from './packem_shared/emitApp-CzZ6GbrD.mjs';
+export { buildOpenApiDocument, emitOpenApi, emitOpenApiModule } from './packem_shared/buildOpenApiDocument-yHVN66Xd.mjs';
+export { OPENRPC_VERSION, buildOpenRpcDocument, emitOpenRpc, emitOpenRpcModule } from './packem_shared/buildOpenRpcDocument-BZGY1-jT.mjs';
+export { SCHEMA_SNAPSHOT_FILENAME, createCodegenProject, refreshCodegenProject, runCodegen } from './packem_shared/createCodegenProject-DGJm0_Pk.mjs';
+export { SCHEMA_SNAPSHOT_VERSION, SchemaSnapshotParseError, buildSchemaSnapshot, diffSchemaSnapshots, evaluateSchemaDrift, parseSchemaSnapshot, serializeSchemaSnapshot } from './packem_shared/buildSchemaSnapshot-DzLDbWk3.mjs';
+export { schemaFromIr } from './packem_shared/schemaFromIr-DTYsLBaA.mjs';
+export { LUNORA_ERROR_CODES, validatorIrToJsonSchema } from './packem_shared/LUNORA_ERROR_CODES-CySpQPD3.mjs';
+
+const VERSION = "0.0.0";
+
+export { VERSION };

package/dist/packem_shared/CONTAINERS_FILENAME-0K-pjNb8.mjs

@@ -0,0 +1,224 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { containerClassName, containerBindingName, normalizeContainerImage } from '@lunora/container';
+import { SyntaxKind, Node } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-54jWDxA9.mjs';
+
+const CONTAINERS_FILENAME = "containers.ts";
+const isDefineContainer = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return identifier.getText() === "defineContainer";
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isImportSpecifier(declaration)) {
+      continue;
+    }
+    if (declaration.getImportDeclaration().getModuleSpecifierValue() !== "@lunora/container") {
+      return false;
+    }
+    return declaration.getNameNode().getText() === "defineContainer";
+  }
+  return false;
+};
+const stringProperty = (expression, exportName, property) => {
+  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  throw diagnosticAt(
+    expression,
+    `container "${exportName}": \`${property}\` must be a static string literal — it is deploy configuration codegen writes into wrangler.jsonc`
+  );
+};
+const numberProperty = (expression, exportName, property) => {
+  if (Node.isNumericLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  throw diagnosticAt(
+    expression,
+    `container "${exportName}": \`${property}\` must be a static number literal — it is deploy configuration codegen writes into wrangler.jsonc`
+  );
+};
+const imageFromExpression = (expression, exportName) => {
+  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+    return normalizeContainerImage(expression.getLiteralValue());
+  }
+  if (Node.isObjectLiteralExpression(expression)) {
+    const registry = expression.getProperty("registry");
+    if (registry && Node.isPropertyAssignment(registry)) {
+      const initializer = registry.getInitializerOrThrow();
+      return normalizeContainerImage({ registry: stringProperty(initializer, exportName, "image.registry") });
+    }
+    const build = expression.getProperty("build");
+    if (build && Node.isPropertyAssignment(build)) {
+      const initializer = build.getInitializerOrThrow();
+      return normalizeContainerImage({ build: stringProperty(initializer, exportName, "image.build") });
+    }
+  }
+  throw diagnosticAt(expression, `container "${exportName}": \`image\` must be a static string path, { registry: "…" }, or { build: "…" } literal`);
+};
+const stringRecordLiteral = (expression) => {
+  if (!Node.isObjectLiteralExpression(expression)) {
+    return void 0;
+  }
+  const record = {};
+  for (const property of expression.getProperties()) {
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+    const value = property.getInitializerOrThrow();
+    if (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value)) {
+      record[property.getName()] = value.getLiteralValue();
+    }
+  }
+  return Object.keys(record).length > 0 ? record : void 0;
+};
+const rolloutLiteral = (expression) => {
+  if (!Node.isObjectLiteralExpression(expression)) {
+    return void 0;
+  }
+  const rollout = {};
+  for (const property of expression.getProperties()) {
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+    const key = property.getName();
+    const value = property.getInitializerOrThrow();
+    if (Node.isNumericLiteral(value) && (key === "gracePeriodSeconds" || key === "stepPercentage")) {
+      rollout[key] = value.getLiteralValue();
+    }
+  }
+  return rollout.gracePeriodSeconds === void 0 && rollout.stepPercentage === void 0 ? void 0 : rollout;
+};
+const booleanLiteral = (expression) => {
+  if (Node.isTrueLiteral(expression)) {
+    return true;
+  }
+  if (Node.isFalseLiteral(expression)) {
+    return false;
+  }
+  return void 0;
+};
+const stringOrNumberLiteral = (expression) => {
+  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  if (Node.isNumericLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  return void 0;
+};
+const instanceTypeFromExpression = (expression, exportName) => {
+  if (Node.isStringLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  if (Node.isObjectLiteralExpression(expression)) {
+    const custom = {};
+    for (const property of expression.getProperties()) {
+      if (!Node.isPropertyAssignment(property)) {
+        throw diagnosticAt(property, `container "${exportName}": \`instanceType\` must be an object of static number literals`);
+      }
+      const key = property.getName();
+      if (key !== "diskMb" && key !== "memoryMib" && key !== "vcpu") {
+        throw diagnosticAt(property, `container "${exportName}": unknown \`instanceType\` field "${key}" — expected vcpu, memoryMib, or diskMb`);
+      }
+      custom[key] = numberProperty(property.getInitializerOrThrow(), exportName, `instanceType.${key}`);
+    }
+    return custom;
+  }
+  throw diagnosticAt(expression, `container "${exportName}": \`instanceType\` must be a static string or { vcpu, memoryMib, diskMb } literal`);
+};
+const containerFromCall = (call, exportName) => {
+  const argument = call.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    throw diagnosticAt(call, `container "${exportName}": defineContainer must be passed an inline object literal`);
+  }
+  const ir = {
+    bindingName: containerBindingName(exportName),
+    className: containerClassName(exportName),
+    exportName,
+    image: { buildContext: ".", dockerfilePath: "./Dockerfile", kind: "dockerfile" }
+  };
+  let sawImage = false;
+  for (const property of argument.getProperties()) {
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+    const key = property.getName();
+    const initializer = property.getInitializerOrThrow();
+    switch (key) {
+      case "buildArgs": {
+        ir.buildArgs = stringRecordLiteral(initializer);
+        break;
+      }
+      case "enableInternet": {
+        ir.enableInternet = booleanLiteral(initializer);
+        break;
+      }
+      case "image": {
+        ir.image = imageFromExpression(initializer, exportName);
+        sawImage = true;
+        break;
+      }
+      case "instanceType": {
+        ir.instanceType = instanceTypeFromExpression(initializer, exportName);
+        break;
+      }
+      case "maxInstances": {
+        ir.maxInstances = numberProperty(initializer, exportName, "maxInstances");
+        break;
+      }
+      case "name": {
+        ir.name = stringProperty(initializer, exportName, "name");
+        break;
+      }
+      case "rollout": {
+        ir.rollout = rolloutLiteral(initializer);
+        break;
+      }
+      case "sleepAfter": {
+        ir.sleepAfter = stringOrNumberLiteral(initializer);
+        break;
+      }
+    }
+  }
+  if (!sawImage) {
+    throw diagnosticAt(argument, `container "${exportName}": defineContainer requires a static \`image\` property`);
+  }
+  return ir;
+};
+const containersFromSource = (source) => {
+  const containers = [];
+  for (const declaration of source.getVariableDeclarations()) {
+    if (!declaration.isExported()) {
+      continue;
+    }
+    const initializer = declaration.getInitializer();
+    if (initializer?.getKind() !== SyntaxKind.CallExpression) {
+      continue;
+    }
+    const call = initializer;
+    const callee = call.getExpression();
+    if (!Node.isIdentifier(callee) || !isDefineContainer(callee)) {
+      continue;
+    }
+    const nameNode = declaration.getNameNode();
+    if (!Node.isIdentifier(nameNode)) {
+      throw diagnosticAt(nameNode, "defineContainer exports must be plain named exports (no destructuring)");
+    }
+    containers.push(containerFromCall(call, nameNode.getText()));
+  }
+  return containers;
+};
+const discoverContainers = (project, lunoraDirectory) => {
+  const containersPath = join(lunoraDirectory, CONTAINERS_FILENAME);
+  if (!existsSync(containersPath)) {
+    return [];
+  }
+  const source = project.getSourceFile(containersPath) ?? project.addSourceFileAtPath(containersPath);
+  const containers = containersFromSource(source);
+  containers.sort((a, b) => a.exportName.localeCompare(b.exportName));
+  return containers;
+};
+
+export { CONTAINERS_FILENAME, discoverContainers };

package/dist/packem_shared/CodegenDiagnosticError-54jWDxA9.mjs

@@ -0,0 +1,22 @@
+class CodegenDiagnosticError extends Error {
+  column;
+  file;
+  line;
+  constructor(message, file, line, column) {
+    super(message);
+    this.name = "CodegenDiagnosticError";
+    this.file = file;
+    this.line = line;
+    this.column = column;
+  }
+}
+const diagnosticAt = (node, detail) => {
+  const sourceFile = node.getSourceFile();
+  const file = sourceFile.getFilePath();
+  const line = node.getStartLineNumber();
+  const { column } = sourceFile.getLineAndColumnAtPos(node.getStart());
+  const message = `@lunora/codegen: ${detail} (${file}:${line.toString()}:${column.toString()})`;
+  return new CodegenDiagnosticError(message, file, line, column);
+};
+
+export { CodegenDiagnosticError, diagnosticAt };

package/dist/packem_shared/LUNORA_ERROR_CODES-CySpQPD3.mjs

@@ -0,0 +1,61 @@
+import { jsonSchemaFromNode, objectSchemaFromNodes } from '@lunora/values';
+
+const literalConst = (literalValue) => {
+  if (literalValue === void 0) {
+    return {};
+  }
+  const trimmed = literalValue.trim();
+  if (trimmed === "true") {
+    return { const: true };
+  }
+  if (trimmed === "false") {
+    return { const: false };
+  }
+  if (trimmed === "null") {
+    return { const: null, type: "null" };
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return { const: trimmed.slice(1, -1), type: "string" };
+  }
+  const asNumber = Number(trimmed);
+  if (!Number.isNaN(asNumber)) {
+    return { const: asNumber };
+  }
+  return { const: trimmed };
+};
+const irReader = {
+  constraints: () => void 0,
+  inner: (validator) => validator.inner,
+  isNullable: (validator) => validator.column?.notNull === false,
+  // `ValidatorIR.kind` is a loose `string` (build-time AST); narrow it to the
+  // shared reader's `ValidatorKind`. Unknown kinds fall through the mapper's
+  // `default` branch to an empty schema, exactly as before.
+  kind: (validator) => validator.kind,
+  literalSchema: (validator) => literalConst(validator.literalValue),
+  members: (validator) => validator.members ?? [],
+  shape: (validator) => validator.shape ?? {},
+  tableName: (validator) => validator.tableName,
+  valueChild: (validator) => validator.valueType
+};
+const validatorIrToJsonSchema = (validator) => jsonSchemaFromNode(validator, irReader);
+const objectSchema = (shape) => objectSchemaFromNodes(shape, irReader);
+const argsObjectSchema = (args) => objectSchema(args);
+const LUNORA_ERROR_CODES = [
+  "BAD_REQUEST",
+  "CONFLICT",
+  "COUNT_RLS_UNSUPPORTED",
+  "FORBIDDEN",
+  "FUNCTION_NOT_FOUND",
+  "INTERNAL",
+  "INTERNAL_SERVER_ERROR",
+  "METHOD_NOT_ALLOWED",
+  "NOT_FOUND",
+  "NOT_IMPLEMENTED",
+  "PAYLOAD_TOO_LARGE",
+  "TOO_MANY_REQUESTS",
+  "UNAUTHORIZED",
+  "UNPROCESSABLE",
+  "VALIDATION_ERROR"
+];
+
+export { LUNORA_ERROR_CODES, argsObjectSchema, literalConst, objectSchema, validatorIrToJsonSchema };

package/dist/packem_shared/buildOpenApiDocument-yHVN66Xd.mjs

@@ -0,0 +1,183 @@
+import { GENERATED_HEADER } from './emitApi-hRVC-kE7.mjs';
+import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
+import { LUNORA_ERROR_CODES, objectSchema, argsObjectSchema, validatorIrToJsonSchema } from './LUNORA_ERROR_CODES-CySpQPD3.mjs';
+
+const ERROR_COMPONENT_REF = "#/components/responses/LunoraError";
+const ROUTE_PARAM_RE = /:([A-Za-z_$][\w$]*)/gu;
+const pathParameterNames = (path) => [...path.matchAll(ROUTE_PARAM_RE)].map((match) => match[1]);
+const toOpenApiPath = (path) => path.replaceAll(ROUTE_PARAM_RE, "{$1}");
+const buildParameters = (route) => {
+  const declaredPathNames = new Set(pathParameterNames(route.path));
+  const parameters = [];
+  for (const [name, validator] of Object.entries(route.searchParams)) {
+    const inner = validator.kind === "optional" ? validator.inner ?? validator : validator;
+    parameters.push({
+      description: `Query parameter \`${name}\``,
+      in: "query",
+      name,
+      required: validator.kind !== "optional",
+      schema: validatorIrToJsonSchema(inner)
+    });
+  }
+  for (const [name, validator] of Object.entries(route.params)) {
+    const inner = validator.kind === "optional" ? validator.inner ?? validator : validator;
+    parameters.push({
+      description: `Path parameter \`${name}\``,
+      // A path param the template doesn't name is still surfaced (OpenAPI
+      // requires path params to be `required: true`), but flagged so the
+      // mismatch is visible rather than silently dropped.
+      in: declaredPathNames.has(name) ? "path" : "query",
+      name,
+      required: declaredPathNames.has(name) ? true : validator.kind !== "optional",
+      schema: validatorIrToJsonSchema(inner)
+    });
+  }
+  return parameters;
+};
+const successResponse = (output) => {
+  if (output) {
+    return {
+      content: { "application/json": { schema: validatorIrToJsonSchema(output) } },
+      description: "Successful response."
+    };
+  }
+  return {
+    content: { "application/json": { schema: { description: "Return shape is TS-inferred (no `.output()` declared); best-effort — any JSON." } } },
+    description: "Successful response. The return shape is TypeScript-inferred and not declared via `.output()`, so it is documented best-effort."
+  };
+};
+const httpRouteOperation = (route) => {
+  const tag = sanitizeNamespace(route.filePath);
+  const parameters = buildParameters(route);
+  const operation = {
+    description: `${route.stream ? "Streaming (SSE) " : ""}HTTP route handler \`${route.exportName}\` (${route.method} ${route.path}).`,
+    operationId: `${route.method.toLowerCase()}_${sanitizeNamespace(route.path)}`,
+    responses: {
+      "200": successResponse(route.output),
+      "204": { description: "No content (handler returned `undefined`)." },
+      default: { $ref: ERROR_COMPONENT_REF }
+    },
+    summary: `${route.method} ${route.path}`,
+    tags: [tag]
+  };
+  if (parameters.length > 0) {
+    operation.parameters = parameters;
+  }
+  if (Object.keys(route.body).length > 0) {
+    operation.requestBody = {
+      content: { "application/json": { schema: objectSchema(route.body) } },
+      required: true
+    };
+  }
+  if (route.stream) {
+    operation["x-lunora-stream"] = "text/event-stream";
+  }
+  return operation;
+};
+const rpcOperation = (definition) => {
+  const functionPath = `${sanitizeNamespace(definition.filePath)}:${definition.exportName}`;
+  const tag = sanitizeNamespace(definition.filePath);
+  const requestSchema = {
+    additionalProperties: false,
+    properties: {
+      args: argsObjectSchema(definition.args),
+      functionPath: { const: functionPath, type: "string" },
+      shardKey: { description: "Optional shard key; omitted routes to the default shard.", type: "string" }
+    },
+    required: ["functionPath"],
+    type: "object"
+  };
+  const operation = {
+    description: `Invoke the \`${definition.kind}\` \`${functionPath}\` over the Lunora RPC envelope (POST /_lunora/rpc).`,
+    operationId: functionPath,
+    requestBody: {
+      content: { "application/json": { schema: requestSchema } },
+      required: true
+    },
+    responses: {
+      "200": {
+        content: {
+          "application/json": {
+            schema: { description: "RPC result. The shape is TS-inferred from the function's return type; best-effort — any JSON." }
+          }
+        },
+        description: "Successful RPC result (TypeScript-inferred return shape, documented best-effort)."
+      },
+      default: { $ref: ERROR_COMPONENT_REF }
+    },
+    summary: `${definition.kind}: ${functionPath}`,
+    tags: [tag],
+    "x-lunora-function-kind": definition.kind
+  };
+  return { operation, pathKey: `/_lunora/rpc#${functionPath}` };
+};
+const buildOpenApiDocument = (input) => {
+  const version = input.version ?? "0.0.0";
+  const paths = {};
+  const tagNames = /* @__PURE__ */ new Set();
+  for (const route of input.httpRoutes) {
+    const openApiPath = toOpenApiPath(route.path);
+    const pathItem = paths[openApiPath] ?? {};
+    pathItem[route.method.toLowerCase()] = httpRouteOperation(route);
+    paths[openApiPath] = pathItem;
+    tagNames.add(sanitizeNamespace(route.filePath));
+  }
+  const rpcFunctions = input.functions.filter((definition) => definition.visibility !== "internal" && definition.kind !== "stream");
+  for (const definition of rpcFunctions) {
+    const { operation, pathKey } = rpcOperation(definition);
+    paths[pathKey] = { post: operation };
+    tagNames.add(sanitizeNamespace(definition.filePath));
+  }
+  const tags = [...tagNames].toSorted((a, b) => a.localeCompare(b)).map((name) => {
+    return { description: `Operations declared in \`lunora/${name}\`.`, name };
+  });
+  const document = {
+    components: {
+      responses: {
+        LunoraError: {
+          content: {
+            "application/json": {
+              schema: {
+                additionalProperties: false,
+                description: "Standard Lunora error envelope.",
+                properties: {
+                  error: {
+                    additionalProperties: false,
+                    properties: {
+                      code: {
+                        description: "Machine-readable error code. Clients switch on this value.",
+                        enum: LUNORA_ERROR_CODES,
+                        type: "string"
+                      },
+                      message: { description: "Human-readable error message (never echoes internal details).", type: "string" }
+                    },
+                    required: ["code", "message"],
+                    type: "object"
+                  }
+                },
+                required: ["error"],
+                type: "object"
+              }
+            }
+          },
+          description: "A Lunora error response. The HTTP status reflects the error code (e.g. BAD_REQUEST→400, UNAUTHORIZED→401, FORBIDDEN→403, NOT_FOUND→404)."
+        }
+      }
+    },
+    info: {
+      description: "Auto-generated from @lunora/values-typed functions by @lunora/codegen. Do not edit — run `lunora codegen` to regenerate.",
+      title: "Lunora API",
+      version
+    },
+    openapi: "3.1.0",
+    paths,
+    tags
+  };
+  return document;
+};
+const emitOpenApi = (input) => `${JSON.stringify(buildOpenApiDocument(input), void 0, 2)}
+`;
+const emitOpenApiModule = (document_) => `${GENERATED_HEADER}export const openApiSpec: Record<string, unknown> = ${JSON.stringify(document_, void 0, 4)};
+`;
+
+export { buildOpenApiDocument, emitOpenApi, emitOpenApiModule };

package/dist/packem_shared/buildOpenRpcDocument-BZGY1-jT.mjs

@@ -0,0 +1,60 @@
+import { GENERATED_HEADER } from './emitApi-hRVC-kE7.mjs';
+import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
+import { argsObjectSchema, LUNORA_ERROR_CODES } from './LUNORA_ERROR_CODES-CySpQPD3.mjs';
+
+const OPENRPC_VERSION = "1.3.2";
+const inferredResultSchema = () => {
+  return { description: "Result is TS-inferred from the function's return type (no `.output()` declared); best-effort — any JSON." };
+};
+const rpcMethod = (definition) => {
+  const namespace = sanitizeNamespace(definition.filePath);
+  const functionPath = `${namespace}:${definition.exportName}`;
+  return {
+    description: `Invoke the \`${definition.kind}\` \`${functionPath}\` over the Lunora RPC envelope (POST /_lunora/rpc, body \`{ "functionPath": "${functionPath}", "args": { … } }\`).`,
+    errors: LUNORA_ERROR_CODES.map((code, index) => {
+      return { code: -32e3 - index, data: { code }, message: code };
+    }),
+    name: functionPath,
+    params: [
+      {
+        description: "The function's argument object (the RPC envelope's `args`).",
+        name: "args",
+        // A function with no declared args still takes an (empty) args
+        // object; `required` reflects whether the function declares any
+        // arguments at all.
+        required: Object.keys(definition.args).length > 0,
+        schema: argsObjectSchema(definition.args)
+      }
+    ],
+    result: {
+      name: "result",
+      schema: inferredResultSchema()
+    },
+    summary: `${definition.kind}: ${functionPath}`,
+    "x-lunora-function-kind": definition.kind,
+    // OpenRPC has no first-class tag grouping; surface the file namespace as
+    // an `x-tags` extension so tooling can group methods by source file.
+    "x-tags": [{ name: namespace }]
+  };
+};
+const buildOpenRpcDocument = (input) => {
+  const version = input.version ?? "0.0.0";
+  const rpcFunctions = input.functions.filter((definition) => definition.visibility !== "internal" && definition.kind !== "stream");
+  const methods = rpcFunctions.map((definition) => rpcMethod(definition)).toSorted((a, b) => a.name.localeCompare(b.name));
+  const document = {
+    info: {
+      description: "Auto-generated from @lunora/values-typed functions by @lunora/codegen. Do not edit — run `lunora codegen` to regenerate.",
+      title: "Lunora RPC",
+      version
+    },
+    methods,
+    openrpc: OPENRPC_VERSION
+  };
+  return document;
+};
+const emitOpenRpc = (input) => `${JSON.stringify(buildOpenRpcDocument(input), void 0, 2)}
+`;
+const emitOpenRpcModule = (document_) => `${GENERATED_HEADER}export const openRpcSpec: Record<string, unknown> = ${JSON.stringify(document_, void 0, 4)};
+`;
+
+export { OPENRPC_VERSION, buildOpenRpcDocument, emitOpenRpc, emitOpenRpcModule };