@palantir/pack.document-schema.type-gen 0.9.0 → 0.11.0

package/build/esm/utils/schema/generateVersionedZodFromSchema.js

@@ -16,67 +16,25 @@
 
 import { formatVariantName } from "../formatVariantName.js";
 import { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
-import { resolveSchemaChain } from "./resolveSchemaChain.js";
-import { findRecordExportName, isRecordSchema, isUnionSchema, schemaName, TypeKind, typesFilePath, versionedSchemaName, versionedTypeName } from "./runtimeSchema.js";
-function convertFieldTypeToZodSchema(fieldType, schema, version) {
-  switch (fieldType.type) {
-    case TypeKind.ANY:
-      return "z.unknown()";
-    case TypeKind.ARRAY:
-      if (fieldType.items == null) {
-        throw new Error("Array field is missing items type");
-      }
-      return `z.array(${convertFieldTypeToZodSchema(fieldType.items, schema, version)})`;
-    case TypeKind.BOOLEAN:
-      return "z.boolean()";
-    case TypeKind.DOC_REF:
-      return "z.string()";
-    case TypeKind.DOUBLE:
-      return "z.number()";
-    case TypeKind.MEDIA_REF:
-      return "z.string()";
-    case TypeKind.OBJECT_REF:
-      return "z.string()";
-    case TypeKind.OPTIONAL:
-      if (fieldType.item == null) {
-        throw new Error("Optional field is missing inner type");
-      }
-      return `${convertFieldTypeToZodSchema(fieldType.item, schema, version)}.optional()`;
-    case TypeKind.REF:
-      {
-        if (fieldType.name == null) {
-          throw new Error("Ref field is missing a name");
-        }
-        const exportName = fieldType.refType === "record" && schema ? findRecordExportName(fieldType.name, schema) ?? fieldType.name : fieldType.name;
-        const refSchemaName = version != null ? versionedSchemaName(exportName, version) : `${exportName}Schema`;
-        const refTypeName = version != null ? versionedTypeName(exportName, version) : exportName;
-        return `z.lazy((): ZodType<${refTypeName}> => ${refSchemaName})`;
-      }
-    case TypeKind.STRING:
-      return "z.string()";
-    case TypeKind.USER_REF:
-      return "z.string()";
-    default:
-      throw new Error(`Unknown schema field type: ${fieldType.type}`);
-  }
-}
-
+import { convertFieldTypeToZodSchema } from "../ir/irFieldHelpers.js";
+import { resolveMinVersion } from "./resolveSchemaChain.js";
+import { typesFilePath, versionedSchemaName, versionedTypeName } from "./runtimeSchema.js";
 /**
  * Generate Zod schemas for a specific schema version.
  * Uses `.passthrough()` to preserve unknown fields.
  */
-function generateZodSchemasForVersion(version, schema) {
+function generateZodSchemasForVersion(version, ir) {
   let output = GENERATED_FILE_HEADER;
 
   // Collect type names for import
   const typeNames = [];
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (isRecordSchema(item)) {
-      typeNames.push(versionedTypeName(exportName, version));
-    } else if (isUnionSchema(item)) {
-      typeNames.push(versionedTypeName(exportName, version));
-      for (const variantName of Object.keys(item.variants)) {
-        typeNames.push(`${versionedTypeName(exportName, version)}${formatVariantName(variantName)}`);
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type === "record") {
+      typeNames.push(versionedTypeName(modelKey, version));
+    } else if (modelDef.type === "union") {
+      typeNames.push(versionedTypeName(modelKey, version));
+      for (const variantName of Object.keys(modelDef.union.variants)) {
+        typeNames.push(`${versionedTypeName(modelKey, version)}${formatVariantName(variantName)}`);
       }
     }
   }
@@ -88,44 +46,52 @@ function generateZodSchemasForVersion(version, schema) {
   output += "\n";
 
   // Generate record schemas first (unions may depend on them)
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (!isRecordSchema(item)) continue;
-    const zodSchemaName = versionedSchemaName(exportName, version);
-    const typeName = versionedTypeName(exportName, version);
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "record") continue;
+    const zodSchemaName = versionedSchemaName(modelKey, version);
+    const typeName = versionedTypeName(modelKey, version);
     const fieldLines = [];
-    for (const [fieldName, fieldType] of Object.entries(item.fields)) {
-      const zodType = convertFieldTypeToZodSchema(fieldType, schema, version);
-      fieldLines.push(`  ${fieldName}: ${zodType}`);
+    for (const field of modelDef.record.fields) {
+      let zodType = convertFieldTypeToZodSchema(field.fieldType, version);
+      if (field.isOptional) {
+        zodType = `${zodType}.optional()`;
+      }
+      fieldLines.push(`  ${field.key}: ${zodType}`);
     }
     output += `export const ${zodSchemaName} = z.object({\n${fieldLines.join(",\n")}\n}).passthrough() satisfies ZodType<${typeName}>;\n\n`;
   }
 
   // Generate union schemas
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (!isUnionSchema(item)) continue;
-    const discriminantField = item.discriminant;
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "union") continue;
+    const union = modelDef.union;
+    const discriminantField = union.discriminant;
     const variantSchemaNames = [];
-    for (const [variantName, variantType] of Object.entries(item.variants)) {
+    for (const [variantName, variantModelKey] of Object.entries(union.variants)) {
       const formattedVariant = formatVariantName(variantName);
-      const variantZodSchemaName = `${versionedSchemaName(exportName, version)}${formattedVariant}`;
-      const variantTypeName = `${versionedTypeName(exportName, version)}${formattedVariant}`;
+      const variantZodSchemaName = `${versionedSchemaName(modelKey, version)}${formattedVariant}`;
+      const variantTypeName = `${versionedTypeName(modelKey, version)}${formattedVariant}`;
       variantSchemaNames.push(variantZodSchemaName);
-      if (variantType.type === TypeKind.REF && variantType.refType === "record") {
-        const recordExport = findRecordExportName(variantType.name, schema);
-        const recordZodSchemaName = recordExport ? versionedSchemaName(recordExport, version) : `${variantType.name}Schema`;
+
+      // Look up the variant's model to check if it's a record
+      const variantModel = ir.models[variantModelKey];
+      if (variantModel != null && variantModel.type === "record") {
+        const recordZodSchemaName = versionedSchemaName(variantModelKey, version);
         output += `export const ${variantZodSchemaName} = ${recordZodSchemaName}.extend({\n`;
         output += `  ${discriminantField}: z.literal("${variantName}")\n`;
         output += `}) satisfies ZodType<${variantTypeName}>;\n\n`;
       } else {
-        const zodType = convertFieldTypeToZodSchema(variantType, schema, version);
+        // Non-record variant (e.g. another union): emit a value field referencing the schema
+        const refZodSchemaName = versionedSchemaName(variantModelKey, version);
+        const refTypeName = versionedTypeName(variantModelKey, version);
         output += `export const ${variantZodSchemaName} = z.object({\n`;
         output += `  ${discriminantField}: z.literal("${variantName}"),\n`;
-        output += `  value: ${zodType}\n`;
+        output += `  value: z.lazy((): ZodType<${refTypeName}> => ${refZodSchemaName})\n`;
         output += `}) satisfies ZodType<${variantTypeName}>;\n\n`;
       }
     }
-    const unionZodSchemaName = versionedSchemaName(exportName, version);
-    const typeName = versionedTypeName(exportName, version);
+    const unionZodSchemaName = versionedSchemaName(modelKey, version);
+    const typeName = versionedTypeName(modelKey, version);
     output += `export const ${unionZodSchemaName} = z.discriminatedUnion("${discriminantField}", [\n  ${variantSchemaNames.join(",\n  ")}\n]) satisfies ZodType<${typeName}>;\n\n`;
   }
   return output;
@@ -135,24 +101,24 @@ function generateZodSchemasForVersion(version, schema) {
  * Generate the schema.ts re-export file mapping unversioned names to latest version.
  */
 function generateSchemaReExport({
-  schema,
+  ir,
   version
 }) {
   let output = GENERATED_FILE_HEADER;
   const reExports = [];
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (isRecordSchema(item)) {
-      const versioned = versionedSchemaName(exportName, version);
-      reExports.push(`export { ${versioned} as ${schemaName(exportName)} } from "./schema_v${version}.js";`);
-    } else if (isUnionSchema(item)) {
-      const versioned = versionedSchemaName(exportName, version);
-      reExports.push(`export { ${versioned} as ${schemaName(exportName)} } from "./schema_v${version}.js";`);
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type === "record") {
+      const versioned = versionedSchemaName(modelKey, version);
+      reExports.push(`export { ${versioned} as ${modelKey}Schema } from "./schema_v${version}.js";`);
+    } else if (modelDef.type === "union") {
+      const versioned = versionedSchemaName(modelKey, version);
+      reExports.push(`export { ${versioned} as ${modelKey}Schema } from "./schema_v${version}.js";`);
 
       // Also re-export union variant schemas
-      for (const variantName of Object.keys(item.variants)) {
+      for (const variantName of Object.keys(modelDef.union.variants)) {
         const formattedVariant = formatVariantName(variantName);
-        const versionedVariant = `${versionedSchemaName(exportName, version)}${formattedVariant}`;
-        reExports.push(`export { ${versionedVariant} as ${`${exportName}${formattedVariant}Schema`} } from "./schema_v${version}.js";`);
+        const versionedVariant = `${versionedSchemaName(modelKey, version)}${formattedVariant}`;
+        reExports.push(`export { ${versionedVariant} as ${`${modelKey}${formattedVariant}Schema`} } from "./schema_v${version}.js";`);
       }
     }
   }
@@ -161,24 +127,22 @@ function generateSchemaReExport({
 }
 
 /**
- * Generate per-version Zod schemas from a schema definition with version chain.
- *
- * @param schema - The schema definition (initial or versioned)
- * @param minSupportedVersion - Minimum version to generate schemas for (defaults to latest)
- * @returns Object containing generated Zod schema code for each output file
+ * Generate per-version Zod schemas from an already-resolved versioned IR chain.
  */
-export function generateVersionedZodFromSchema(schema, minSupportedVersion) {
+export function generateVersionedZodFromChain(resolved, minSupportedVersion) {
+  const {
+    chain
+  } = resolved;
   const {
-    chain,
     minVersion
-  } = resolveSchemaChain(schema, minSupportedVersion);
+  } = resolveMinVersion(chain, minSupportedVersion);
   const zodSchemas = new Map();
   for (const {
     version,
-    schema: versionSchema
+    ir
   } of chain) {
     if (version < minVersion) continue;
-    zodSchemas.set(version, generateZodSchemasForVersion(version, versionSchema));
+    zodSchemas.set(version, generateZodSchemasForVersion(version, ir));
   }
   const schemaReExport = generateSchemaReExport(chain[chain.length - 1]);
   return {

package/build/esm/utils/schema/generateVersionedZodFromSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateVersionedZodFromSchema.js","names":["formatVariantName","GENERATED_FILE_HEADER","resolveSchemaChain","findRecordExportName","isRecordSchema","isUnionSchema","schemaName","TypeKind","typesFilePath","versionedSchemaName","versionedTypeName","convertFieldTypeToZodSchema","fieldType","schema","version","type","ANY","ARRAY","items","Error","BOOLEAN","DOC_REF","DOUBLE","MEDIA_REF","OBJECT_REF","OPTIONAL","item","REF","name","exportName","refType","refSchemaName","refTypeName","STRING","USER_REF","generateZodSchemasForVersion","output","typeNames","Object","entries","push","variantName","keys","variants","length","sort","join","zodSchemaName","typeName","fieldLines","fieldName","fields","zodType","discriminantField","discriminant","variantSchemaNames","variantType","formattedVariant","variantZodSchemaName","variantTypeName","recordExport","recordZodSchemaName","unionZodSchemaName","generateSchemaReExport","reExports","versioned","versionedVariant","generateVersionedZodFromSchema","minSupportedVersion","chain","minVersion","zodSchemas","Map","versionSchema","set","schemaReExport"],"sources":["generateVersionedZodFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { SchemaDefinition } from \"@palantir/pack.schema\";\nimport { formatVariantName } from \"../formatVariantName.js\";\nimport { GENERATED_FILE_HEADER } from \"../generatedFileHeader.js\";\nimport type { VersionedSchemaEntry } from \"./resolveSchemaChain.js\";\nimport { resolveSchemaChain } from \"./resolveSchemaChain.js\";\nimport type { RuntimeSchema, SchemaField } from \"./runtimeSchema.js\";\nimport {\n  findRecordExportName,\n  isRecordSchema,\n  isUnionSchema,\n  schemaName,\n  TypeKind,\n  typesFilePath,\n  versionedSchemaName,\n  versionedTypeName,\n} from \"./runtimeSchema.js\";\n\nexport interface VersionedZodOutput {\n  /** schema_vN.ts files keyed by version number */\n  zodSchemas: Map<number, string>;\n  /** schema.ts re-export of latest version schemas under unversioned names */\n  schemaReExport: string;\n}\n\nfunction convertFieldTypeToZodSchema(\n  fieldType: SchemaField,\n  schema?: RuntimeSchema,\n  version?: number,\n): string {\n  switch (fieldType.type) {\n    case TypeKind.ANY:\n      return \"z.unknown()\";\n    case TypeKind.ARRAY:\n      if (fieldType.items == null) {\n        throw new Error(\"Array field is missing items type\");\n      }\n      return `z.array(${convertFieldTypeToZodSchema(fieldType.items, schema, version)})`;\n    case TypeKind.BOOLEAN:\n      return \"z.boolean()\";\n    case TypeKind.DOC_REF:\n      return \"z.string()\";\n    case TypeKind.DOUBLE:\n      return \"z.number()\";\n    case TypeKind.MEDIA_REF:\n      return \"z.string()\";\n    case TypeKind.OBJECT_REF:\n      return \"z.string()\";\n    case TypeKind.OPTIONAL:\n      if (fieldType.item == null) {\n        throw new Error(\"Optional field is missing inner type\");\n      }\n      return `${convertFieldTypeToZodSchema(fieldType.item, schema, version)}.optional()`;\n    case TypeKind.REF: {\n      if (fieldType.name == null) {\n        throw new Error(\"Ref field is missing a name\");\n      }\n      const exportName = fieldType.refType === \"record\" && schema\n        ? findRecordExportName(fieldType.name, schema) ?? fieldType.name\n        : fieldType.name;\n      const refSchemaName = version != null\n        ? versionedSchemaName(exportName, version)\n        : `${exportName}Schema`;\n      const refTypeName = version != null ? versionedTypeName(exportName, version) : exportName;\n      return `z.lazy((): ZodType<${refTypeName}> => ${refSchemaName})`;\n    }\n    case TypeKind.STRING:\n      return \"z.string()\";\n    case TypeKind.USER_REF:\n      return \"z.string()\";\n    default:\n      throw new Error(`Unknown schema field type: ${fieldType.type}`);\n  }\n}\n\n/**\n * Generate Zod schemas for a specific schema version.\n * Uses `.passthrough()` to preserve unknown fields.\n */\nfunction generateZodSchemasForVersion(\n  version: number,\n  schema: RuntimeSchema,\n): string {\n  let output = GENERATED_FILE_HEADER;\n\n  // Collect type names for import\n  const typeNames: string[] = [];\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (isRecordSchema(item)) {\n      typeNames.push(versionedTypeName(exportName, version));\n    } else if (isUnionSchema(item)) {\n      typeNames.push(versionedTypeName(exportName, version));\n      for (const variantName of Object.keys(item.variants)) {\n        typeNames.push(\n          `${versionedTypeName(exportName, version)}${formatVariantName(variantName)}`,\n        );\n      }\n    }\n  }\n\n  output += \"import type { ZodType } from \\\"zod\\\";\\n\";\n  output += \"import { z } from \\\"zod\\\";\\n\";\n\n  if (typeNames.length > 0) {\n    output += `import type { ${typeNames.sort().join(\", \")} } from \"${typesFilePath(version)}\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record schemas first (unions may depend on them)\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (!isRecordSchema(item)) continue;\n\n    const zodSchemaName = versionedSchemaName(exportName, version);\n    const typeName = versionedTypeName(exportName, version);\n    const fieldLines: string[] = [];\n\n    for (const [fieldName, fieldType] of Object.entries(item.fields)) {\n      const zodType = convertFieldTypeToZodSchema(fieldType, schema, version);\n      fieldLines.push(`  ${fieldName}: ${zodType}`);\n    }\n\n    output += `export const ${zodSchemaName} = z.object({\\n${\n      fieldLines.join(\",\\n\")\n    }\\n}).passthrough() satisfies ZodType<${typeName}>;\\n\\n`;\n  }\n\n  // Generate union schemas\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (!isUnionSchema(item)) continue;\n\n    const discriminantField = item.discriminant;\n    const variantSchemaNames: string[] = [];\n\n    for (const [variantName, variantType] of Object.entries(item.variants)) {\n      const formattedVariant = formatVariantName(variantName);\n      const variantZodSchemaName = `${versionedSchemaName(exportName, version)}${formattedVariant}`;\n      const variantTypeName = `${versionedTypeName(exportName, version)}${formattedVariant}`;\n      variantSchemaNames.push(variantZodSchemaName);\n\n      if (variantType.type === TypeKind.REF && variantType.refType === \"record\") {\n        const recordExport = findRecordExportName(variantType.name!, schema);\n        const recordZodSchemaName = recordExport\n          ? versionedSchemaName(recordExport, version)\n          : `${variantType.name!}Schema`;\n        output += `export const ${variantZodSchemaName} = ${recordZodSchemaName}.extend({\\n`;\n        output += `  ${discriminantField}: z.literal(\"${variantName}\")\\n`;\n        output += `}) satisfies ZodType<${variantTypeName}>;\\n\\n`;\n      } else {\n        const zodType = convertFieldTypeToZodSchema(variantType, schema, version);\n        output += `export const ${variantZodSchemaName} = z.object({\\n`;\n        output += `  ${discriminantField}: z.literal(\"${variantName}\"),\\n`;\n        output += `  value: ${zodType}\\n`;\n        output += `}) satisfies ZodType<${variantTypeName}>;\\n\\n`;\n      }\n    }\n\n    const unionZodSchemaName = versionedSchemaName(exportName, version);\n    const typeName = versionedTypeName(exportName, version);\n    output +=\n      `export const ${unionZodSchemaName} = z.discriminatedUnion(\"${discriminantField}\", [\\n  ${\n        variantSchemaNames.join(\",\\n  \")\n      }\\n]) satisfies ZodType<${typeName}>;\\n\\n`;\n  }\n\n  return output;\n}\n\n/**\n * Generate the schema.ts re-export file mapping unversioned names to latest version.\n */\nfunction generateSchemaReExport(\n  { schema, version }: VersionedSchemaEntry,\n): string {\n  let output = GENERATED_FILE_HEADER;\n\n  const reExports: string[] = [];\n\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (isRecordSchema(item)) {\n      const versioned = versionedSchemaName(exportName, version);\n      reExports.push(\n        `export { ${versioned} as ${schemaName(exportName)} } from \"./schema_v${version}.js\";`,\n      );\n    } else if (isUnionSchema(item)) {\n      const versioned = versionedSchemaName(exportName, version);\n      reExports.push(\n        `export { ${versioned} as ${schemaName(exportName)} } from \"./schema_v${version}.js\";`,\n      );\n\n      // Also re-export union variant schemas\n      for (const variantName of Object.keys(item.variants)) {\n        const formattedVariant = formatVariantName(variantName);\n        const versionedVariant = `${versionedSchemaName(exportName, version)}${formattedVariant}`;\n        const unversionedVariant = `${exportName}${formattedVariant}Schema`;\n        reExports.push(\n          `export { ${versionedVariant} as ${unversionedVariant} } from \"./schema_v${version}.js\";`,\n        );\n      }\n    }\n  }\n\n  output += reExports.join(\"\\n\") + \"\\n\";\n\n  return output;\n}\n\n/**\n * Generate per-version Zod schemas from a schema definition with version chain.\n *\n * @param schema - The schema definition (initial or versioned)\n * @param minSupportedVersion - Minimum version to generate schemas for (defaults to latest)\n * @returns Object containing generated Zod schema code for each output file\n */\nexport function generateVersionedZodFromSchema(\n  schema: SchemaDefinition,\n  minSupportedVersion?: number,\n): VersionedZodOutput {\n  const { chain, minVersion } = resolveSchemaChain(schema, minSupportedVersion);\n\n  const zodSchemas = new Map<number, string>();\n\n  for (const { version, schema: versionSchema } of chain) {\n    if (version < minVersion) continue;\n\n    zodSchemas.set(version, generateZodSchemasForVersion(version, versionSchema));\n  }\n\n  const schemaReExport = generateSchemaReExport(chain[chain.length - 1]!);\n\n  return { zodSchemas, schemaReExport };\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"generateVersionedZodFromSchema.js","names":["formatVariantName","GENERATED_FILE_HEADER","convertFieldTypeToZodSchema","resolveMinVersion","typesFilePath","versionedSchemaName","versionedTypeName","generateZodSchemasForVersion","version","ir","output","typeNames","modelKey","modelDef","Object","entries","models","type","push","variantName","keys","union","variants","length","sort","join","zodSchemaName","typeName","fieldLines","field","record","fields","zodType","fieldType","isOptional","key","discriminantField","discriminant","variantSchemaNames","variantModelKey","formattedVariant","variantZodSchemaName","variantTypeName","variantModel","recordZodSchemaName","refZodSchemaName","refTypeName","unionZodSchemaName","generateSchemaReExport","reExports","versioned","versionedVariant","generateVersionedZodFromChain","resolved","minSupportedVersion","chain","minVersion","zodSchemas","Map","set","schemaReExport"],"sources":["generateVersionedZodFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { IRealTimeDocumentSchema } from \"../../lib/pack-docschema-api/pack-docschema-ir/index.js\";\nimport { formatVariantName } from \"../formatVariantName.js\";\nimport { GENERATED_FILE_HEADER } from \"../generatedFileHeader.js\";\nimport { convertFieldTypeToZodSchema } from \"../ir/irFieldHelpers.js\";\nimport type { ResolvedIrChain, VersionedIrEntry } from \"./resolveSchemaChain.js\";\nimport { resolveMinVersion } from \"./resolveSchemaChain.js\";\nimport { typesFilePath, versionedSchemaName, versionedTypeName } from \"./runtimeSchema.js\";\n\nexport interface VersionedZodOutput {\n  /** schema_vN.ts files keyed by version number */\n  zodSchemas: Map<number, string>;\n  /** schema.ts re-export of latest version schemas under unversioned names */\n  schemaReExport: string;\n}\n\n/**\n * Generate Zod schemas for a specific schema version.\n * Uses `.passthrough()` to preserve unknown fields.\n */\nfunction generateZodSchemasForVersion(\n  version: number,\n  ir: IRealTimeDocumentSchema,\n): string {\n  let output = GENERATED_FILE_HEADER;\n\n  // Collect type names for import\n  const typeNames: string[] = [];\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type === \"record\") {\n      typeNames.push(versionedTypeName(modelKey, version));\n    } else if (modelDef.type === \"union\") {\n      typeNames.push(versionedTypeName(modelKey, version));\n      for (const variantName of Object.keys(modelDef.union.variants)) {\n        typeNames.push(\n          `${versionedTypeName(modelKey, version)}${formatVariantName(variantName)}`,\n        );\n      }\n    }\n  }\n\n  output += \"import type { ZodType } from \\\"zod\\\";\\n\";\n  output += \"import { z } from \\\"zod\\\";\\n\";\n\n  if (typeNames.length > 0) {\n    output += `import type { ${typeNames.sort().join(\", \")} } from \"${typesFilePath(version)}\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record schemas first (unions may depend on them)\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type !== \"record\") continue;\n\n    const zodSchemaName = versionedSchemaName(modelKey, version);\n    const typeName = versionedTypeName(modelKey, version);\n    const fieldLines: string[] = [];\n\n    for (const field of modelDef.record.fields) {\n      let zodType = convertFieldTypeToZodSchema(field.fieldType, version);\n      if (field.isOptional) {\n        zodType = `${zodType}.optional()`;\n      }\n      fieldLines.push(`  ${field.key}: ${zodType}`);\n    }\n\n    output += `export const ${zodSchemaName} = z.object({\\n${\n      fieldLines.join(\",\\n\")\n    }\\n}).passthrough() satisfies ZodType<${typeName}>;\\n\\n`;\n  }\n\n  // Generate union schemas\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type !== \"union\") continue;\n\n    const union = modelDef.union;\n    const discriminantField = union.discriminant;\n    const variantSchemaNames: string[] = [];\n\n    for (const [variantName, variantModelKey] of Object.entries(union.variants)) {\n      const formattedVariant = formatVariantName(variantName);\n      const variantZodSchemaName = `${versionedSchemaName(modelKey, version)}${formattedVariant}`;\n      const variantTypeName = `${versionedTypeName(modelKey, version)}${formattedVariant}`;\n      variantSchemaNames.push(variantZodSchemaName);\n\n      // Look up the variant's model to check if it's a record\n      const variantModel = ir.models[variantModelKey];\n      if (variantModel != null && variantModel.type === \"record\") {\n        const recordZodSchemaName = versionedSchemaName(variantModelKey, version);\n        output += `export const ${variantZodSchemaName} = ${recordZodSchemaName}.extend({\\n`;\n        output += `  ${discriminantField}: z.literal(\"${variantName}\")\\n`;\n        output += `}) satisfies ZodType<${variantTypeName}>;\\n\\n`;\n      } else {\n        // Non-record variant (e.g. another union): emit a value field referencing the schema\n        const refZodSchemaName = versionedSchemaName(variantModelKey, version);\n        const refTypeName = versionedTypeName(variantModelKey, version);\n        output += `export const ${variantZodSchemaName} = z.object({\\n`;\n        output += `  ${discriminantField}: z.literal(\"${variantName}\"),\\n`;\n        output += `  value: z.lazy((): ZodType<${refTypeName}> => ${refZodSchemaName})\\n`;\n        output += `}) satisfies ZodType<${variantTypeName}>;\\n\\n`;\n      }\n    }\n\n    const unionZodSchemaName = versionedSchemaName(modelKey, version);\n    const typeName = versionedTypeName(modelKey, version);\n    output +=\n      `export const ${unionZodSchemaName} = z.discriminatedUnion(\"${discriminantField}\", [\\n  ${\n        variantSchemaNames.join(\",\\n  \")\n      }\\n]) satisfies ZodType<${typeName}>;\\n\\n`;\n  }\n\n  return output;\n}\n\n/**\n * Generate the schema.ts re-export file mapping unversioned names to latest version.\n */\nfunction generateSchemaReExport(\n  { ir, version }: VersionedIrEntry,\n): string {\n  let output = GENERATED_FILE_HEADER;\n\n  const reExports: string[] = [];\n\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type === \"record\") {\n      const versioned = versionedSchemaName(modelKey, version);\n      reExports.push(\n        `export { ${versioned} as ${modelKey}Schema } from \"./schema_v${version}.js\";`,\n      );\n    } else if (modelDef.type === \"union\") {\n      const versioned = versionedSchemaName(modelKey, version);\n      reExports.push(\n        `export { ${versioned} as ${modelKey}Schema } from \"./schema_v${version}.js\";`,\n      );\n\n      // Also re-export union variant schemas\n      for (const variantName of Object.keys(modelDef.union.variants)) {\n        const formattedVariant = formatVariantName(variantName);\n        const versionedVariant = `${versionedSchemaName(modelKey, version)}${formattedVariant}`;\n        const unversionedVariant = `${modelKey}${formattedVariant}Schema`;\n        reExports.push(\n          `export { ${versionedVariant} as ${unversionedVariant} } from \"./schema_v${version}.js\";`,\n        );\n      }\n    }\n  }\n\n  output += reExports.join(\"\\n\") + \"\\n\";\n\n  return output;\n}\n\n/**\n * Generate per-version Zod schemas from an already-resolved versioned IR chain.\n */\nexport function generateVersionedZodFromChain(\n  resolved: ResolvedIrChain,\n  minSupportedVersion?: number,\n): VersionedZodOutput {\n  const { chain } = resolved;\n  const { minVersion } = resolveMinVersion(chain, minSupportedVersion);\n\n  const zodSchemas = new Map<number, string>();\n\n  for (const { version, ir } of chain) {\n    if (version < minVersion) continue;\n\n    zodSchemas.set(version, generateZodSchemasForVersion(version, ir));\n  }\n\n  const schemaReExport = generateSchemaReExport(chain[chain.length - 1]!);\n\n  return { zodSchemas, schemaReExport };\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/utils/schema/generateVersionsFromSchema.js

@@ -15,10 +15,10 @@
  */
 
 import { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
-import { resolveSchemaChain } from "./resolveSchemaChain.js";
+import { resolveMinVersion } from "./resolveSchemaChain.js";
 
 /**
- * Generate versions.ts from a versioned schema chain.
+ * Generate versions.ts from an already-resolved versioned IR chain.
  *
  * Output:
  * ```
@@ -27,12 +27,14 @@ import { resolveSchemaChain } from "./resolveSchemaChain.js";
  * export type MinSupportedVersion = 1;
  * ```
  */
-export function generateVersionsFromSchema(schema, minSupportedVersion) {
+export function generateVersionsFromChain(resolved, minSupportedVersion) {
+  const {
+    chain
+  } = resolved;
   const {
-    chain,
     latestVersion,
     minVersion
-  } = resolveSchemaChain(schema, minSupportedVersion);
+  } = resolveMinVersion(chain, minSupportedVersion);
   const supportedVersions = [];
   for (const {
     version

package/build/esm/utils/schema/generateVersionsFromSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateVersionsFromSchema.js","names":["GENERATED_FILE_HEADER","resolveSchemaChain","generateVersionsFromSchema","schema","minSupportedVersion","chain","latestVersion","minVersion","supportedVersions","version","push","output","join"],"sources":["generateVersionsFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { SchemaDefinition } from \"@palantir/pack.schema\";\nimport { GENERATED_FILE_HEADER } from \"../generatedFileHeader.js\";\nimport { resolveSchemaChain } from \"./resolveSchemaChain.js\";\n\n/**\n * Generate versions.ts from a versioned schema chain.\n *\n * Output:\n * ```\n * export type SupportedVersions = 1 | 2;\n * export type LatestVersion = 2;\n * export type MinSupportedVersion = 1;\n * ```\n */\nexport function generateVersionsFromSchema(\n  schema: SchemaDefinition,\n  minSupportedVersion?: number,\n): string {\n  const { chain, latestVersion, minVersion } = resolveSchemaChain(schema, minSupportedVersion);\n\n  const supportedVersions: number[] = [];\n  for (const { version } of chain) {\n    if (version >= minVersion) {\n      supportedVersions.push(version);\n    }\n  }\n\n  let output = GENERATED_FILE_HEADER;\n  output += `export type SupportedVersions = ${supportedVersions.join(\" | \")};\\n`;\n  output += `export type LatestVersion = ${latestVersion};\\n`;\n  output += `export type MinSupportedVersion = ${minVersion};\\n`;\n\n  return output;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,SAASA,qBAAqB,QAAQ,2BAA2B;AACjE,SAASC,kBAAkB,QAAQ,yBAAyB;;AAE5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,0BAA0BA,CACxCC,MAAwB,EACxBC,mBAA4B,EACpB;EACR,MAAM;IAAEC,KAAK;IAAEC,aAAa;IAAEC;EAAW,CAAC,GAAGN,kBAAkB,CAACE,MAAM,EAAEC,mBAAmB,CAAC;EAE5F,MAAMI,iBAA2B,GAAG,EAAE;EACtC,KAAK,MAAM;IAAEC;EAAQ,CAAC,IAAIJ,KAAK,EAAE;IAC/B,IAAII,OAAO,IAAIF,UAAU,EAAE;MACzBC,iBAAiB,CAACE,IAAI,CAACD,OAAO,CAAC;IACjC;EACF;EAEA,IAAIE,MAAM,GAAGX,qBAAqB;EAClCW,MAAM,IAAI,mCAAmCH,iBAAiB,CAACI,IAAI,CAAC,KAAK,CAAC,KAAK;EAC/ED,MAAM,IAAI,+BAA+BL,aAAa,KAAK;EAC3DK,MAAM,IAAI,qCAAqCJ,UAAU,KAAK;EAE9D,OAAOI,MAAM;AACf","ignoreList":[]}
+{"version":3,"file":"generateVersionsFromSchema.js","names":["GENERATED_FILE_HEADER","resolveMinVersion","generateVersionsFromChain","resolved","minSupportedVersion","chain","latestVersion","minVersion","supportedVersions","version","push","output","join"],"sources":["generateVersionsFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { GENERATED_FILE_HEADER } from \"../generatedFileHeader.js\";\nimport type { ResolvedIrChain } from \"./resolveSchemaChain.js\";\nimport { resolveMinVersion } from \"./resolveSchemaChain.js\";\n\n/**\n * Generate versions.ts from an already-resolved versioned IR chain.\n *\n * Output:\n * ```\n * export type SupportedVersions = 1 | 2;\n * export type LatestVersion = 2;\n * export type MinSupportedVersion = 1;\n * ```\n */\nexport function generateVersionsFromChain(\n  resolved: ResolvedIrChain,\n  minSupportedVersion?: number,\n): string {\n  const { chain } = resolved;\n  const { latestVersion, minVersion } = resolveMinVersion(chain, minSupportedVersion);\n\n  const supportedVersions: number[] = [];\n  for (const { version } of chain) {\n    if (version >= minVersion) {\n      supportedVersions.push(version);\n    }\n  }\n\n  let output = GENERATED_FILE_HEADER;\n  output += `export type SupportedVersions = ${supportedVersions.join(\" | \")};\\n`;\n  output += `export type LatestVersion = ${latestVersion};\\n`;\n  output += `export type MinSupportedVersion = ${minVersion};\\n`;\n\n  return output;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,qBAAqB,QAAQ,2BAA2B;AAEjE,SAASC,iBAAiB,QAAQ,yBAAyB;;AAE3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,yBAAyBA,CACvCC,QAAyB,EACzBC,mBAA4B,EACpB;EACR,MAAM;IAAEC;EAAM,CAAC,GAAGF,QAAQ;EAC1B,MAAM;IAAEG,aAAa;IAAEC;EAAW,CAAC,GAAGN,iBAAiB,CAACI,KAAK,EAAED,mBAAmB,CAAC;EAEnF,MAAMI,iBAA2B,GAAG,EAAE;EACtC,KAAK,MAAM;IAAEC;EAAQ,CAAC,IAAIJ,KAAK,EAAE;IAC/B,IAAII,OAAO,IAAIF,UAAU,EAAE;MACzBC,iBAAiB,CAACE,IAAI,CAACD,OAAO,CAAC;IACjC;EACF;EAEA,IAAIE,MAAM,GAAGX,qBAAqB;EAClCW,MAAM,IAAI,mCAAmCH,iBAAiB,CAACI,IAAI,CAAC,KAAK,CAAC,KAAK;EAC/ED,MAAM,IAAI,+BAA+BL,aAAa,KAAK;EAC3DK,MAAM,IAAI,qCAAqCJ,UAAU,KAAK;EAE9D,OAAOI,MAAM;AACf","ignoreList":[]}

package/build/esm/utils/schema/loadSchemaModule.js

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2026 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import fs from "fs-extra";
+import path from "path";
+import { pathToFileURL } from "url";
+import { extractValidSchema } from "./validateSchemaModule.js";
+
+/**
+ * Pull a `SchemaDefinition` out of an imported module. Accepts either a chain
+ * built via `defineSchemaUpdate(...)` (`type: "initial" | "versioned"`) or a
+ * plain `ModelDefs` object exported as `default` (which is wrapped in an
+ * `InitialSchema` at version 1).
+ */
+export function extractSchemaDefinition(schemaModule) {
+  const defaultExport = schemaModule.default;
+  if (typeof defaultExport === "object" && defaultExport != null && "type" in defaultExport && (defaultExport.type === "initial" || defaultExport.type === "versioned")) {
+    return defaultExport;
+  }
+  const models = extractValidSchema(schemaModule);
+  return {
+    type: "initial",
+    version: 1,
+    models
+  };
+}
+
+/**
+ * Resolve and import a schema module from a file path, returning a
+ * `SchemaDefinition` ready for IR resolution.
+ */
+export async function loadSchemaModule(filePath) {
+  const inputPath = path.resolve(filePath);
+  if (!(await fs.pathExists(inputPath))) {
+    throw new Error(`Input file not found: ${inputPath}`);
+  }
+  const schemaModule = await import(pathToFileURL(inputPath).href);
+  return extractSchemaDefinition(schemaModule);
+}
+//# sourceMappingURL=loadSchemaModule.js.map

package/build/esm/utils/schema/loadSchemaModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadSchemaModule.js","names":["fs","path","pathToFileURL","extractValidSchema","extractSchemaDefinition","schemaModule","defaultExport","default","type","models","version","loadSchemaModule","filePath","inputPath","resolve","pathExists","Error","href"],"sources":["loadSchemaModule.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { InitialSchema, SchemaDefinition } from \"@palantir/pack.schema\";\nimport fs from \"fs-extra\";\nimport path from \"path\";\nimport { pathToFileURL } from \"url\";\nimport { extractValidSchema } from \"./validateSchemaModule.js\";\n\n/**\n * Pull a `SchemaDefinition` out of an imported module. Accepts either a chain\n * built via `defineSchemaUpdate(...)` (`type: \"initial\" | \"versioned\"`) or a\n * plain `ModelDefs` object exported as `default` (which is wrapped in an\n * `InitialSchema` at version 1).\n */\nexport function extractSchemaDefinition(schemaModule: unknown): SchemaDefinition {\n  const mod = schemaModule as Record<string, unknown>;\n  const defaultExport = mod.default;\n\n  if (\n    typeof defaultExport === \"object\" && defaultExport != null\n    && \"type\" in defaultExport\n    && (defaultExport.type === \"initial\" || defaultExport.type === \"versioned\")\n  ) {\n    return defaultExport as SchemaDefinition;\n  }\n\n  const models = extractValidSchema(schemaModule);\n  return { type: \"initial\", version: 1, models } satisfies InitialSchema;\n}\n\n/**\n * Resolve and import a schema module from a file path, returning a\n * `SchemaDefinition` ready for IR resolution.\n */\nexport async function loadSchemaModule(filePath: string): Promise<SchemaDefinition> {\n  const inputPath = path.resolve(filePath);\n  if (!(await fs.pathExists(inputPath))) {\n    throw new Error(`Input file not found: ${inputPath}`);\n  }\n  const schemaModule: unknown = await import(pathToFileURL(inputPath).href);\n  return extractSchemaDefinition(schemaModule);\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,OAAOA,EAAE,MAAM,UAAU;AACzB,OAAOC,IAAI,MAAM,MAAM;AACvB,SAASC,aAAa,QAAQ,KAAK;AACnC,SAASC,kBAAkB,QAAQ,2BAA2B;;AAE9D;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,uBAAuBA,CAACC,YAAqB,EAAoB;EAE/E,MAAMC,aAAa,GADPD,YAAY,CACEE,OAAO;EAEjC,IACE,OAAOD,aAAa,KAAK,QAAQ,IAAIA,aAAa,IAAI,IAAI,IACvD,MAAM,IAAIA,aAAa,KACtBA,aAAa,CAACE,IAAI,KAAK,SAAS,IAAIF,aAAa,CAACE,IAAI,KAAK,WAAW,CAAC,EAC3E;IACA,OAAOF,aAAa;EACtB;EAEA,MAAMG,MAAM,GAAGN,kBAAkB,CAACE,YAAY,CAAC;EAC/C,OAAO;IAAEG,IAAI,EAAE,SAAS;IAAEE,OAAO,EAAE,CAAC;IAAED;EAAO,CAAC;AAChD;;AAEA;AACA;AACA;AACA;AACA,OAAO,eAAeE,gBAAgBA,CAACC,QAAgB,EAA6B;EAClF,MAAMC,SAAS,GAAGZ,IAAI,CAACa,OAAO,CAACF,QAAQ,CAAC;EACxC,IAAI,EAAE,MAAMZ,EAAE,CAACe,UAAU,CAACF,SAAS,CAAC,CAAC,EAAE;IACrC,MAAM,IAAIG,KAAK,CAAC,yBAAyBH,SAAS,EAAE,CAAC;EACvD;EACA,MAAMR,YAAqB,GAAG,MAAM,MAAM,CAACH,aAAa,CAACW,SAAS,CAAC,CAACI,IAAI,CAAC;EACzE,OAAOb,uBAAuB,CAACC,YAAY,CAAC;AAC9C","ignoreList":[]}

package/build/esm/utils/schema/resolveSchemaChain.js

@@ -14,30 +14,55 @@
  * limitations under the License.
  */
 
-function collectVersionedSchemaChain(input) {
+import { convertSchemaToIr } from "../steps/convertStepsToIr.js";
+
+/** JSON-serializable form of a single field migration. */
+
+/** Serialized migrations keyed by `[recordModelName][fieldName]`. */
+
+function collectVersionedIrChain(input) {
   const chain = [];
   let current = input;
   while (current.type === "versioned") {
     chain.unshift({
       version: current.version,
-      schema: current.models,
-      migrations: current.migrations
+      ir: convertSchemaToIr(current.models, {
+        version: current.version
+      }),
+      migrations: serializeMigrations(current.migrations)
     });
     current = current.previous;
   }
   chain.unshift({
     version: current.version,
-    schema: current.models
+    ir: convertSchemaToIr(current.models, {
+      version: current.version
+    })
   });
   return chain;
 }
 
+/** Convert schema-builder migrations to their JSON-serializable form. */
+function serializeMigrations(migrations) {
+  if (migrations == null) return undefined;
+  const result = {};
+  for (const [modelKey, fields] of Object.entries(migrations)) {
+    const fieldEntries = {};
+    for (const [fieldName, migration] of Object.entries(fields)) {
+      fieldEntries[fieldName] = {
+        derivedFrom: [...migration.derivedFrom]
+      };
+    }
+    result[modelKey] = fieldEntries;
+  }
+  return result;
+}
+
 /**
- * Collect the version chain and resolve min/latest versions.
- * Throws on empty chain or invalid minSupportedVersion.
+ * Validate `minSupportedVersion` against an already-resolved chain and return
+ * the effective `minVersion`. Throws on invalid input.
  */
-export function resolveSchemaChain(schema, minSupportedVersion) {
-  const chain = collectVersionedSchemaChain(schema);
+export function resolveMinVersion(chain, minSupportedVersion) {
   if (chain.length === 0) {
     throw new Error("Schema version chain is empty");
   }
@@ -46,9 +71,43 @@ export function resolveSchemaChain(schema, minSupportedVersion) {
     throw new Error(`minSupportedVersion ${minSupportedVersion} is not in the schema chain ` + `(available versions: ${chain.map(c => c.version).join(", ")})`);
   }
   return {
-    chain,
     latestVersion,
     minVersion: minSupportedVersion ?? latestVersion
   };
 }
+
+/**
+ * Collect the version chain and resolve min/latest versions.
+ * Each version's models are converted to IR (IRealTimeDocumentSchema).
+ * Throws on empty chain or invalid minSupportedVersion.
+ */
+export function resolveSchemaChain(schema, minSupportedVersion) {
+  const chain = collectVersionedIrChain(schema);
+  const {
+    latestVersion,
+    minVersion
+  } = resolveMinVersion(chain, minSupportedVersion);
+  return {
+    chain,
+    latestVersion,
+    minVersion
+  };
+}
+
+/**
+ * True if any migration in the chain declares a non-empty `derivedFrom`. Drives
+ * whether the generated SDK emits `DocumentModel` as a factory (requires the
+ * app to supply typed upgrade functions) or as a const (no upgrade functions needed).
+ */
+export function chainHasDerivedFields(chain) {
+  for (const entry of chain) {
+    if (entry.migrations == null) continue;
+    for (const recordMigrations of Object.values(entry.migrations)) {
+      for (const fieldMigration of Object.values(recordMigrations)) {
+        if (fieldMigration.derivedFrom.length > 0) return true;
+      }
+    }
+  }
+  return false;
+}
 //# sourceMappingURL=resolveSchemaChain.js.map

package/build/esm/utils/schema/resolveSchemaChain.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolveSchemaChain.js","names":["collectVersionedSchemaChain","input","chain","current","type","unshift","version","schema","models","migrations","previous","resolveSchemaChain","minSupportedVersion","length","Error","latestVersion","some","c","map","join","minVersion"],"sources":["resolveSchemaChain.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { SchemaDefinition, VersionMigrations } from \"@palantir/pack.schema\";\nimport type { RuntimeSchema } from \"./runtimeSchema.js\";\n\nexport interface VersionedSchemaEntry {\n  version: number;\n  schema: RuntimeSchema;\n  migrations?: VersionMigrations;\n}\n\nexport interface ResolvedSchemaChain {\n  chain: VersionedSchemaEntry[];\n  latestVersion: number;\n  minVersion: number;\n}\n\nfunction collectVersionedSchemaChain(input: SchemaDefinition): VersionedSchemaEntry[] {\n  const chain: VersionedSchemaEntry[] = [];\n  let current: SchemaDefinition = input;\n\n  while (current.type === \"versioned\") {\n    chain.unshift({\n      version: current.version,\n      schema: current.models as RuntimeSchema,\n      migrations: current.migrations,\n    });\n    current = current.previous;\n  }\n  chain.unshift({ version: current.version, schema: current.models as RuntimeSchema });\n\n  return chain;\n}\n\n/**\n * Collect the version chain and resolve min/latest versions.\n * Throws on empty chain or invalid minSupportedVersion.\n */\nexport function resolveSchemaChain(\n  schema: SchemaDefinition,\n  minSupportedVersion?: number,\n): ResolvedSchemaChain {\n  const chain = collectVersionedSchemaChain(schema);\n\n  if (chain.length === 0) {\n    throw new Error(\"Schema version chain is empty\");\n  }\n\n  const latestVersion = chain[chain.length - 1]!.version;\n\n  if (minSupportedVersion != null && !chain.some(c => c.version === minSupportedVersion)) {\n    throw new Error(\n      `minSupportedVersion ${minSupportedVersion} is not in the schema chain `\n        + `(available versions: ${chain.map(c => c.version).join(\", \")})`,\n    );\n  }\n\n  const minVersion = minSupportedVersion ?? latestVersion;\n\n  return { chain, latestVersion, minVersion };\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAiBA,SAASA,2BAA2BA,CAACC,KAAuB,EAA0B;EACpF,MAAMC,KAA6B,GAAG,EAAE;EACxC,IAAIC,OAAyB,GAAGF,KAAK;EAErC,OAAOE,OAAO,CAACC,IAAI,KAAK,WAAW,EAAE;IACnCF,KAAK,CAACG,OAAO,CAAC;MACZC,OAAO,EAAEH,OAAO,CAACG,OAAO;MACxBC,MAAM,EAAEJ,OAAO,CAACK,MAAuB;MACvCC,UAAU,EAAEN,OAAO,CAACM;IACtB,CAAC,CAAC;IACFN,OAAO,GAAGA,OAAO,CAACO,QAAQ;EAC5B;EACAR,KAAK,CAACG,OAAO,CAAC;IAAEC,OAAO,EAAEH,OAAO,CAACG,OAAO;IAAEC,MAAM,EAAEJ,OAAO,CAACK;EAAwB,CAAC,CAAC;EAEpF,OAAON,KAAK;AACd;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASS,kBAAkBA,CAChCJ,MAAwB,EACxBK,mBAA4B,EACP;EACrB,MAAMV,KAAK,GAAGF,2BAA2B,CAACO,MAAM,CAAC;EAEjD,IAAIL,KAAK,CAACW,MAAM,KAAK,CAAC,EAAE;IACtB,MAAM,IAAIC,KAAK,CAAC,+BAA+B,CAAC;EAClD;EAEA,MAAMC,aAAa,GAAGb,KAAK,CAACA,KAAK,CAACW,MAAM,GAAG,CAAC,CAAC,CAAEP,OAAO;EAEtD,IAAIM,mBAAmB,IAAI,IAAI,IAAI,CAACV,KAAK,CAACc,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACX,OAAO,KAAKM,mBAAmB,CAAC,EAAE;IACtF,MAAM,IAAIE,KAAK,CACb,uBAAuBF,mBAAmB,8BAA8B,GACpE,wBAAwBV,KAAK,CAACgB,GAAG,CAACD,CAAC,IAAIA,CAAC,CAACX,OAAO,CAAC,CAACa,IAAI,CAAC,IAAI,CAAC,GAClE,CAAC;EACH;EAIA,OAAO;IAAEjB,KAAK;IAAEa,aAAa;IAAEK,UAAU,EAFtBR,mBAAmB,IAAIG;EAEA,CAAC;AAC7C","ignoreList":[]}
+{"version":3,"file":"resolveSchemaChain.js","names":["convertSchemaToIr","collectVersionedIrChain","input","chain","current","type","unshift","version","ir","models","migrations","serializeMigrations","previous","undefined","result","modelKey","fields","Object","entries","fieldEntries","fieldName","migration","derivedFrom","resolveMinVersion","minSupportedVersion","length","Error","latestVersion","some","c","map","join","minVersion","resolveSchemaChain","schema","chainHasDerivedFields","entry","recordMigrations","values","fieldMigration"],"sources":["resolveSchemaChain.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { SchemaDefinition, VersionMigrations } from \"@palantir/pack.schema\";\nimport type { IRealTimeDocumentSchema } from \"../../lib/pack-docschema-api/pack-docschema-ir/index.js\";\nimport { convertSchemaToIr } from \"../steps/convertStepsToIr.js\";\n\n/** JSON-serializable form of a single field migration. */\nexport interface SerializedFieldMigration {\n  readonly derivedFrom: readonly string[];\n}\n\n/** Serialized migrations keyed by `[recordModelName][fieldName]`. */\nexport type SerializedVersionMigrations = Record<\n  string,\n  Record<string, SerializedFieldMigration>\n>;\n\nexport interface VersionedIrEntry {\n  version: number;\n  ir: IRealTimeDocumentSchema;\n  migrations?: SerializedVersionMigrations;\n}\n\nexport interface ResolvedIrChain {\n  chain: VersionedIrEntry[];\n  latestVersion: number;\n  minVersion: number;\n}\n\nfunction collectVersionedIrChain(input: SchemaDefinition): VersionedIrEntry[] {\n  const chain: VersionedIrEntry[] = [];\n  let current: SchemaDefinition = input;\n\n  while (current.type === \"versioned\") {\n    chain.unshift({\n      version: current.version,\n      ir: convertSchemaToIr(current.models, { version: current.version }),\n      migrations: serializeMigrations(current.migrations),\n    });\n    current = current.previous;\n  }\n  chain.unshift({\n    version: current.version,\n    ir: convertSchemaToIr(current.models, { version: current.version }),\n  });\n\n  return chain;\n}\n\n/** Convert schema-builder migrations to their JSON-serializable form. */\nfunction serializeMigrations(\n  migrations: VersionMigrations | undefined,\n): SerializedVersionMigrations | undefined {\n  if (migrations == null) return undefined;\n  const result: SerializedVersionMigrations = {};\n  for (const [modelKey, fields] of Object.entries(migrations)) {\n    const fieldEntries: Record<string, SerializedFieldMigration> = {};\n    for (const [fieldName, migration] of Object.entries(fields)) {\n      fieldEntries[fieldName] = {\n        derivedFrom: [...migration.derivedFrom],\n      };\n    }\n    result[modelKey] = fieldEntries;\n  }\n  return result;\n}\n\n/**\n * Validate `minSupportedVersion` against an already-resolved chain and return\n * the effective `minVersion`. Throws on invalid input.\n */\nexport function resolveMinVersion(\n  chain: VersionedIrEntry[],\n  minSupportedVersion: number | undefined,\n): { latestVersion: number; minVersion: number } {\n  if (chain.length === 0) {\n    throw new Error(\"Schema version chain is empty\");\n  }\n\n  const latestVersion = chain[chain.length - 1]!.version;\n\n  if (minSupportedVersion != null && !chain.some(c => c.version === minSupportedVersion)) {\n    throw new Error(\n      `minSupportedVersion ${minSupportedVersion} is not in the schema chain `\n        + `(available versions: ${chain.map(c => c.version).join(\", \")})`,\n    );\n  }\n\n  return {\n    latestVersion,\n    minVersion: minSupportedVersion ?? latestVersion,\n  };\n}\n\n/**\n * Collect the version chain and resolve min/latest versions.\n * Each version's models are converted to IR (IRealTimeDocumentSchema).\n * Throws on empty chain or invalid minSupportedVersion.\n */\nexport function resolveSchemaChain(\n  schema: SchemaDefinition,\n  minSupportedVersion?: number,\n): ResolvedIrChain {\n  const chain = collectVersionedIrChain(schema);\n  const { latestVersion, minVersion } = resolveMinVersion(chain, minSupportedVersion);\n  return { chain, latestVersion, minVersion };\n}\n\n/**\n * True if any migration in the chain declares a non-empty `derivedFrom`. Drives\n * whether the generated SDK emits `DocumentModel` as a factory (requires the\n * app to supply typed upgrade functions) or as a const (no upgrade functions needed).\n */\nexport function chainHasDerivedFields(chain: VersionedIrEntry[]): boolean {\n  for (const entry of chain) {\n    if (entry.migrations == null) continue;\n    for (const recordMigrations of Object.values(entry.migrations)) {\n      for (const fieldMigration of Object.values(recordMigrations)) {\n        if (fieldMigration.derivedFrom.length > 0) return true;\n      }\n    }\n  }\n  return false;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/utils/schema/runtimeSchema.js

@@ -14,33 +14,6 @@
  * limitations under the License.
  */
 
-import { TypeKind as SchemaTypeKind } from "@palantir/pack.schema";
-export const TypeKind = {
-  ...SchemaTypeKind,
-  ANY: "any"
-};
-export const SchemaDefKind = {
-  RECORD: "record",
-  UNION: "union"
-};
-
-// Runtime types mirroring the schema structure
-
-export function isRecordSchema(item) {
-  return item.type === SchemaDefKind.RECORD && "fields" in item;
-}
-export function isUnionSchema(item) {
-  return item.type === SchemaDefKind.UNION && "variants" in item;
-}
-export function findRecordExportName(recordName, schema) {
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (isRecordSchema(item) && item.name === recordName) {
-      return exportName;
-    }
-  }
-  return null;
-}
-
 /** Versioned read type name: `RecordName_vN` */
 export function versionedTypeName(exportName, version) {
   return `${exportName}_v${version}`;
@@ -88,6 +61,9 @@ export const MODELS_PATH = "./models.js";
 /** Internal upgrades file path: `./_internal/upgrades.js` */
 export const INTERNAL_UPGRADES_PATH = "./_internal/upgrades.js";
 
+/** Internal upgrade-functions file path: `./_internal/upgradeFns.js` */
+export const INTERNAL_UPGRADE_FNS_PATH = "./_internal/upgradeFns.js";
+
 /** Versions file path: `./versions.js` */
 export const VERSIONS_PATH = "./versions.js";
 

package/build/esm/utils/schema/runtimeSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeSchema.js","names":["TypeKind","SchemaTypeKind","ANY","SchemaDefKind","RECORD","UNION","isRecordSchema","item","type","isUnionSchema","findRecordExportName","recordName","schema","exportName","Object","entries","name","versionedTypeName","version","versionedWriteTypeName","versionedSchemaName","modelName","schemaName","typesFilePath","writeTypesFilePath","TYPES_REEXPORT_PATH","SCHEMA_REEXPORT_PATH","MODELS_PATH","INTERNAL_UPGRADES_PATH","VERSIONS_PATH","VERSIONED_DOC_REF_PATH"],"sources":["runtimeSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypeKind as SchemaTypeKind } from \"@palantir/pack.schema\";\n\nexport const TypeKind: typeof SchemaTypeKind & { readonly ANY: \"any\" } = {\n  ...SchemaTypeKind,\n  ANY: \"any\",\n};\n\nexport const SchemaDefKind = {\n  RECORD: \"record\",\n  UNION: \"union\",\n} as const;\n\n// Runtime types mirroring the schema structure\nexport interface SchemaField {\n  readonly type: string;\n  readonly items?: SchemaField;\n  readonly item?: SchemaField;\n  readonly refType?: \"record\" | \"union\";\n  readonly name?: string;\n}\n\nexport interface RuntimeSchemaRecord {\n  readonly type: typeof SchemaDefKind.RECORD;\n  readonly name: string;\n  readonly docs?: string;\n  readonly fields: Readonly<Record<string, SchemaField>>;\n}\n\nexport interface RuntimeSchemaUnion {\n  readonly type: typeof SchemaDefKind.UNION;\n  readonly name?: string;\n  readonly variants: Readonly<Record<string, SchemaField>>;\n  readonly discriminant: string;\n}\n\nexport type RuntimeSchemaItem = RuntimeSchemaRecord | RuntimeSchemaUnion;\nexport type RuntimeSchema = Record<string, RuntimeSchemaItem>;\n\nexport function isRecordSchema(item: RuntimeSchemaItem): item is RuntimeSchemaRecord {\n  return item.type === SchemaDefKind.RECORD && \"fields\" in item;\n}\n\nexport function isUnionSchema(item: RuntimeSchemaItem): item is RuntimeSchemaUnion {\n  return item.type === SchemaDefKind.UNION && \"variants\" in item;\n}\n\nexport function findRecordExportName(recordName: string, schema: RuntimeSchema): string | null {\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (isRecordSchema(item) && item.name === recordName) {\n      return exportName;\n    }\n  }\n  return null;\n}\n\n/** Versioned read type name: `RecordName_vN` */\nexport function versionedTypeName(exportName: string, version: number): string {\n  return `${exportName}_v${version}`;\n}\n\n/** Versioned write type name: `RecordNameUpdate_vN` */\nexport function versionedWriteTypeName(exportName: string, version: number): string {\n  return `${exportName}Update_v${version}`;\n}\n\n/** Versioned Zod schema name: `RecordNameSchema_vN` */\nexport function versionedSchemaName(exportName: string, version: number): string {\n  return `${exportName}Schema_v${version}`;\n}\n\n/** Model constant name: `RecordNameModel` */\nexport function modelName(exportName: string): string {\n  return `${exportName}Model`;\n}\n\n/** Unversioned Zod schema name: `RecordNameSchema` */\nexport function schemaName(exportName: string): string {\n  return `${exportName}Schema`;\n}\n\n/** Per-version types file path: `./types_vN.js` */\nexport function typesFilePath(version: number): string {\n  return `./types_v${version}.js`;\n}\n\n/** Per-version write types file path: `./writeTypes_vN.js` */\nexport function writeTypesFilePath(version: number): string {\n  return `./writeTypes_v${version}.js`;\n}\n\n/** Types re-export file path: `./types.js` */\nexport const TYPES_REEXPORT_PATH = \"./types.js\";\n\n/** Schema re-export file path: `./schema.js` */\nexport const SCHEMA_REEXPORT_PATH = \"./schema.js\";\n\n/** Models file path: `./models.js` */\nexport const MODELS_PATH = \"./models.js\";\n\n/** Internal upgrades file path: `./_internal/upgrades.js` */\nexport const INTERNAL_UPGRADES_PATH = \"./_internal/upgrades.js\";\n\n/** Versions file path: `./versions.js` */\nexport const VERSIONS_PATH = \"./versions.js\";\n\n/** Versioned doc ref file path: `./versionedDocRef.js` */\nexport const VERSIONED_DOC_REF_PATH = \"./versionedDocRef.js\";\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,QAAQ,IAAIC,cAAc,QAAQ,uBAAuB;AAElE,OAAO,MAAMD,QAAyD,GAAG;EACvE,GAAGC,cAAc;EACjBC,GAAG,EAAE;AACP,CAAC;AAED,OAAO,MAAMC,aAAa,GAAG;EAC3BC,MAAM,EAAE,QAAQ;EAChBC,KAAK,EAAE;AACT,CAAU;;AAEV;;AA0BA,OAAO,SAASC,cAAcA,CAACC,IAAuB,EAA+B;EACnF,OAAOA,IAAI,CAACC,IAAI,KAAKL,aAAa,CAACC,MAAM,IAAI,QAAQ,IAAIG,IAAI;AAC/D;AAEA,OAAO,SAASE,aAAaA,CAACF,IAAuB,EAA8B;EACjF,OAAOA,IAAI,CAACC,IAAI,KAAKL,aAAa,CAACE,KAAK,IAAI,UAAU,IAAIE,IAAI;AAChE;AAEA,OAAO,SAASG,oBAAoBA,CAACC,UAAkB,EAAEC,MAAqB,EAAiB;EAC7F,KAAK,MAAM,CAACC,UAAU,EAAEN,IAAI,CAAC,IAAIO,MAAM,CAACC,OAAO,CAACH,MAAM,CAAC,EAAE;IACvD,IAAIN,cAAc,CAACC,IAAI,CAAC,IAAIA,IAAI,CAACS,IAAI,KAAKL,UAAU,EAAE;MACpD,OAAOE,UAAU;IACnB;EACF;EACA,OAAO,IAAI;AACb;;AAEA;AACA,OAAO,SAASI,iBAAiBA,CAACJ,UAAkB,EAAEK,OAAe,EAAU;EAC7E,OAAO,GAAGL,UAAU,KAAKK,OAAO,EAAE;AACpC;;AAEA;AACA,OAAO,SAASC,sBAAsBA,CAACN,UAAkB,EAAEK,OAAe,EAAU;EAClF,OAAO,GAAGL,UAAU,WAAWK,OAAO,EAAE;AAC1C;;AAEA;AACA,OAAO,SAASE,mBAAmBA,CAACP,UAAkB,EAAEK,OAAe,EAAU;EAC/E,OAAO,GAAGL,UAAU,WAAWK,OAAO,EAAE;AAC1C;;AAEA;AACA,OAAO,SAASG,SAASA,CAACR,UAAkB,EAAU;EACpD,OAAO,GAAGA,UAAU,OAAO;AAC7B;;AAEA;AACA,OAAO,SAASS,UAAUA,CAACT,UAAkB,EAAU;EACrD,OAAO,GAAGA,UAAU,QAAQ;AAC9B;;AAEA;AACA,OAAO,SAASU,aAAaA,CAACL,OAAe,EAAU;EACrD,OAAO,YAAYA,OAAO,KAAK;AACjC;;AAEA;AACA,OAAO,SAASM,kBAAkBA,CAACN,OAAe,EAAU;EAC1D,OAAO,iBAAiBA,OAAO,KAAK;AACtC;;AAEA;AACA,OAAO,MAAMO,mBAAmB,GAAG,YAAY;;AAE/C;AACA,OAAO,MAAMC,oBAAoB,GAAG,aAAa;;AAEjD;AACA,OAAO,MAAMC,WAAW,GAAG,aAAa;;AAExC;AACA,OAAO,MAAMC,sBAAsB,GAAG,yBAAyB;;AAE/D;AACA,OAAO,MAAMC,aAAa,GAAG,eAAe;;AAE5C;AACA,OAAO,MAAMC,sBAAsB,GAAG,sBAAsB","ignoreList":[]}
+{"version":3,"file":"runtimeSchema.js","names":["versionedTypeName","exportName","version","versionedWriteTypeName","versionedSchemaName","modelName","schemaName","typesFilePath","writeTypesFilePath","TYPES_REEXPORT_PATH","SCHEMA_REEXPORT_PATH","MODELS_PATH","INTERNAL_UPGRADES_PATH","INTERNAL_UPGRADE_FNS_PATH","VERSIONS_PATH","VERSIONED_DOC_REF_PATH"],"sources":["runtimeSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/** Versioned read type name: `RecordName_vN` */\nexport function versionedTypeName(exportName: string, version: number): string {\n  return `${exportName}_v${version}`;\n}\n\n/** Versioned write type name: `RecordNameUpdate_vN` */\nexport function versionedWriteTypeName(exportName: string, version: number): string {\n  return `${exportName}Update_v${version}`;\n}\n\n/** Versioned Zod schema name: `RecordNameSchema_vN` */\nexport function versionedSchemaName(exportName: string, version: number): string {\n  return `${exportName}Schema_v${version}`;\n}\n\n/** Model constant name: `RecordNameModel` */\nexport function modelName(exportName: string): string {\n  return `${exportName}Model`;\n}\n\n/** Unversioned Zod schema name: `RecordNameSchema` */\nexport function schemaName(exportName: string): string {\n  return `${exportName}Schema`;\n}\n\n/** Per-version types file path: `./types_vN.js` */\nexport function typesFilePath(version: number): string {\n  return `./types_v${version}.js`;\n}\n\n/** Per-version write types file path: `./writeTypes_vN.js` */\nexport function writeTypesFilePath(version: number): string {\n  return `./writeTypes_v${version}.js`;\n}\n\n/** Types re-export file path: `./types.js` */\nexport const TYPES_REEXPORT_PATH = \"./types.js\";\n\n/** Schema re-export file path: `./schema.js` */\nexport const SCHEMA_REEXPORT_PATH = \"./schema.js\";\n\n/** Models file path: `./models.js` */\nexport const MODELS_PATH = \"./models.js\";\n\n/** Internal upgrades file path: `./_internal/upgrades.js` */\nexport const INTERNAL_UPGRADES_PATH = \"./_internal/upgrades.js\";\n\n/** Internal upgrade-functions file path: `./_internal/upgradeFns.js` */\nexport const INTERNAL_UPGRADE_FNS_PATH = \"./_internal/upgradeFns.js\";\n\n/** Versions file path: `./versions.js` */\nexport const VERSIONS_PATH = \"./versions.js\";\n\n/** Versioned doc ref file path: `./versionedDocRef.js` */\nexport const VERSIONED_DOC_REF_PATH = \"./versionedDocRef.js\";\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,OAAO,SAASA,iBAAiBA,CAACC,UAAkB,EAAEC,OAAe,EAAU;EAC7E,OAAO,GAAGD,UAAU,KAAKC,OAAO,EAAE;AACpC;;AAEA;AACA,OAAO,SAASC,sBAAsBA,CAACF,UAAkB,EAAEC,OAAe,EAAU;EAClF,OAAO,GAAGD,UAAU,WAAWC,OAAO,EAAE;AAC1C;;AAEA;AACA,OAAO,SAASE,mBAAmBA,CAACH,UAAkB,EAAEC,OAAe,EAAU;EAC/E,OAAO,GAAGD,UAAU,WAAWC,OAAO,EAAE;AAC1C;;AAEA;AACA,OAAO,SAASG,SAASA,CAACJ,UAAkB,EAAU;EACpD,OAAO,GAAGA,UAAU,OAAO;AAC7B;;AAEA;AACA,OAAO,SAASK,UAAUA,CAACL,UAAkB,EAAU;EACrD,OAAO,GAAGA,UAAU,QAAQ;AAC9B;;AAEA;AACA,OAAO,SAASM,aAAaA,CAACL,OAAe,EAAU;EACrD,OAAO,YAAYA,OAAO,KAAK;AACjC;;AAEA;AACA,OAAO,SAASM,kBAAkBA,CAACN,OAAe,EAAU;EAC1D,OAAO,iBAAiBA,OAAO,KAAK;AACtC;;AAEA;AACA,OAAO,MAAMO,mBAAmB,GAAG,YAAY;;AAE/C;AACA,OAAO,MAAMC,oBAAoB,GAAG,aAAa;;AAEjD;AACA,OAAO,MAAMC,WAAW,GAAG,aAAa;;AAExC;AACA,OAAO,MAAMC,sBAAsB,GAAG,yBAAyB;;AAE/D;AACA,OAAO,MAAMC,yBAAyB,GAAG,2BAA2B;;AAEpE;AACA,OAAO,MAAMC,aAAa,GAAG,eAAe;;AAE5C;AACA,OAAO,MAAMC,sBAAsB,GAAG,sBAAsB","ignoreList":[]}