@palantir/pack.document-schema.type-gen 0.8.0 → 0.10.0

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

@@ -0,0 +1,187 @@
+/*
+ * 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 { formatVariantName } from "../formatVariantName.js";
+import { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
+import { collectReferencedTypes, convertFieldTypeToTypeScript, detectUsedRefTypes } from "../ir/irFieldHelpers.js";
+import { resolveMinVersion } from "./resolveSchemaChain.js";
+import { typesFilePath, versionedTypeName, versionedWriteTypeName } from "./runtimeSchema.js";
+/**
+ * Generate read types for a specific schema version.
+ */
+function generateReadTypesForVersion(version, ir) {
+  const usedRefTypes = detectUsedRefTypes(ir);
+  let output = GENERATED_FILE_HEADER;
+  if (usedRefTypes.size > 0) {
+    const refTypesList = Array.from(usedRefTypes).sort().join(", ");
+    output += `import type { ${refTypesList} } from "@palantir/pack.document-schema.model-types";\n`;
+  }
+  output += "\n";
+
+  // Generate record interfaces
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "record") continue;
+    const record = modelDef.record;
+    const typeName = versionedTypeName(modelKey, version);
+    if (record.description) {
+      output += `/**\n * ${record.description}\n */\n`;
+    }
+    output += `export interface ${typeName} {\n`;
+    for (const field of record.fields) {
+      const tsType = convertFieldTypeToTypeScript(field.fieldType, version);
+      const optional = field.isOptional ? "?" : "";
+      output += `  readonly ${field.key}${optional}: ${tsType};\n`;
+    }
+    output += "}\n\n";
+  }
+
+  // Generate union types
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "union") continue;
+    const union = modelDef.union;
+    const typeName = versionedTypeName(modelKey, version);
+    const discriminantField = union.discriminant;
+    const variantInterfaces = [];
+    for (const [variantName, variantModelKey] of Object.entries(union.variants)) {
+      const interfaceName = `${typeName}${formatVariantName(variantName)}`;
+      variantInterfaces.push({
+        name: interfaceName,
+        discriminatorValue: variantName
+      });
+
+      // 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 recordTypeName = versionedTypeName(variantModelKey, version);
+        output += `export interface ${interfaceName} extends ${recordTypeName} {\n`;
+        output += `  readonly ${discriminantField}: "${variantName}";\n`;
+        output += "}\n\n";
+      } else {
+        // Non-record variant (e.g. another union): emit a value field referencing the type
+        const tsType = versionedTypeName(variantModelKey, version);
+        output += `export interface ${interfaceName} {\n`;
+        output += `  readonly ${discriminantField}: "${variantName}";\n`;
+        output += `  readonly value: ${tsType};\n`;
+        output += "}\n\n";
+      }
+    }
+    output += `export type ${typeName} = ${variantInterfaces.map(v => v.name).join(" | ")};\n\n`;
+    for (const variant of variantInterfaces) {
+      output += `export function is${variant.name}(value: ${typeName}): value is ${variant.name} {\n`;
+      output += `  return value.${discriminantField} === "${variant.discriminatorValue}";\n`;
+      output += "}\n\n";
+    }
+  }
+  return output;
+}
+
+/**
+ * Generate write types for a specific schema version.
+ * All fields are optional in write types.
+ */
+function generateWriteTypesForVersion(version, ir) {
+  const usedRefTypes = detectUsedRefTypes(ir);
+
+  // Collect referenced schema-local types (refs to other records/unions)
+  const referencedLocalTypes = new Set();
+  for (const modelDef of Object.values(ir.models)) {
+    if (modelDef.type !== "record") continue;
+    for (const field of modelDef.record.fields) {
+      collectReferencedTypes(field.fieldType, version, referencedLocalTypes);
+    }
+  }
+  let output = GENERATED_FILE_HEADER;
+  if (usedRefTypes.size > 0) {
+    const refTypesList = Array.from(usedRefTypes).sort().join(", ");
+    output += `import type { ${refTypesList} } from "@palantir/pack.document-schema.model-types";\n`;
+  }
+  if (referencedLocalTypes.size > 0) {
+    const localTypesList = Array.from(referencedLocalTypes).sort().join(", ");
+    output += `import type { ${localTypesList} } from "${typesFilePath(version)}";\n`;
+  }
+  output += "\n";
+
+  // Generate record write types
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "record") continue;
+    const typeName = versionedWriteTypeName(modelKey, version);
+    output += `export type ${typeName} = {\n`;
+    for (const field of modelDef.record.fields) {
+      // All fields are optional in write types
+      const tsType = convertFieldTypeToTypeScript(field.fieldType, version);
+      output += `  readonly ${field.key}?: ${tsType};\n`;
+    }
+    output += "};\n\n";
+  }
+  return output;
+}
+
+/**
+ * Generate the types.ts re-export file that maps unversioned names to the latest version.
+ */
+function generateTypesReExport({
+  ir,
+  version
+}) {
+  const reExports = [];
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type === "record") {
+      const versioned = versionedTypeName(modelKey, version);
+      reExports.push(`export type { ${versioned} as ${modelKey} } from "${typesFilePath(version)}";`);
+    } else if (modelDef.type === "union") {
+      const versioned = versionedTypeName(modelKey, version);
+      reExports.push(`export type { ${versioned} as ${modelKey} } from "${typesFilePath(version)}";`);
+
+      // Also re-export union variant types
+      for (const variantName of Object.keys(modelDef.union.variants)) {
+        const formattedVariant = formatVariantName(variantName);
+        const versionedVariant = `${versionedTypeName(modelKey, version)}${formattedVariant}`;
+        reExports.push(`export type { ${versionedVariant} as ${`${modelKey}${formattedVariant}`} } from "${typesFilePath(version)}";`);
+      }
+    }
+  }
+  return GENERATED_FILE_HEADER + reExports.join("\n") + "\n";
+}
+
+/**
+ * Generate per-version public types and write types from an already-resolved
+ * versioned IR chain.
+ */
+export function generateVersionedTypesFromChain(resolved, minSupportedVersion) {
+  const {
+    chain
+  } = resolved;
+  const {
+    minVersion
+  } = resolveMinVersion(chain, minSupportedVersion);
+  const readTypes = new Map();
+  const writeTypes = new Map();
+  for (const {
+    version,
+    ir
+  } of chain) {
+    if (version < minVersion) continue;
+    readTypes.set(version, generateReadTypesForVersion(version, ir));
+    writeTypes.set(version, generateWriteTypesForVersion(version, ir));
+  }
+  const typesReExport = generateTypesReExport(chain[chain.length - 1]);
+  return {
+    readTypes,
+    writeTypes,
+    typesReExport
+  };
+}
+//# sourceMappingURL=generateVersionedTypesFromSchema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateVersionedTypesFromSchema.js","names":["formatVariantName","GENERATED_FILE_HEADER","collectReferencedTypes","convertFieldTypeToTypeScript","detectUsedRefTypes","resolveMinVersion","typesFilePath","versionedTypeName","versionedWriteTypeName","generateReadTypesForVersion","version","ir","usedRefTypes","output","size","refTypesList","Array","from","sort","join","modelKey","modelDef","Object","entries","models","type","record","typeName","description","field","fields","tsType","fieldType","optional","isOptional","key","union","discriminantField","discriminant","variantInterfaces","variantName","variantModelKey","variants","interfaceName","push","name","discriminatorValue","variantModel","recordTypeName","map","v","variant","generateWriteTypesForVersion","referencedLocalTypes","Set","values","localTypesList","generateTypesReExport","reExports","versioned","keys","formattedVariant","versionedVariant","generateVersionedTypesFromChain","resolved","minSupportedVersion","chain","minVersion","readTypes","Map","writeTypes","set","typesReExport","length"],"sources":["generateVersionedTypesFromSchema.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 {\n  collectReferencedTypes,\n  convertFieldTypeToTypeScript,\n  detectUsedRefTypes,\n} from \"../ir/irFieldHelpers.js\";\nimport type { ResolvedIrChain, VersionedIrEntry } from \"./resolveSchemaChain.js\";\nimport { resolveMinVersion } from \"./resolveSchemaChain.js\";\nimport { typesFilePath, versionedTypeName, versionedWriteTypeName } from \"./runtimeSchema.js\";\n\nexport interface VersionedTypesOutput {\n  /** types_vN.ts files keyed by version number */\n  readTypes: Map<number, string>;\n  /** writeTypes_vN.ts files keyed by version number */\n  writeTypes: Map<number, string>;\n  /** types.ts re-export of latest version types under unversioned names */\n  typesReExport: string;\n}\n\n/**\n * Generate read types for a specific schema version.\n */\nfunction generateReadTypesForVersion(\n  version: number,\n  ir: IRealTimeDocumentSchema,\n): string {\n  const usedRefTypes = detectUsedRefTypes(ir);\n\n  let output = GENERATED_FILE_HEADER;\n\n  if (usedRefTypes.size > 0) {\n    const refTypesList = Array.from(usedRefTypes).sort().join(\", \");\n    output +=\n      `import type { ${refTypesList} } from \"@palantir/pack.document-schema.model-types\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record interfaces\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type !== \"record\") continue;\n\n    const record = modelDef.record;\n    const typeName = versionedTypeName(modelKey, version);\n\n    if (record.description) {\n      output += `/**\\n * ${record.description}\\n */\\n`;\n    }\n\n    output += `export interface ${typeName} {\\n`;\n\n    for (const field of record.fields) {\n      const tsType = convertFieldTypeToTypeScript(field.fieldType, version);\n      const optional = field.isOptional ? \"?\" : \"\";\n      output += `  readonly ${field.key}${optional}: ${tsType};\\n`;\n    }\n\n    output += \"}\\n\\n\";\n  }\n\n  // Generate union types\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type !== \"union\") continue;\n\n    const union = modelDef.union;\n    const typeName = versionedTypeName(modelKey, version);\n    const discriminantField = union.discriminant;\n    const variantInterfaces: Array<{ name: string; discriminatorValue: string }> = [];\n\n    for (const [variantName, variantModelKey] of Object.entries(union.variants)) {\n      const interfaceName = `${typeName}${formatVariantName(variantName)}`;\n      variantInterfaces.push({ name: interfaceName, discriminatorValue: variantName });\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 recordTypeName = versionedTypeName(variantModelKey, version);\n        output += `export interface ${interfaceName} extends ${recordTypeName} {\\n`;\n        output += `  readonly ${discriminantField}: \"${variantName}\";\\n`;\n        output += \"}\\n\\n\";\n      } else {\n        // Non-record variant (e.g. another union): emit a value field referencing the type\n        const tsType = versionedTypeName(variantModelKey, version);\n        output += `export interface ${interfaceName} {\\n`;\n        output += `  readonly ${discriminantField}: \"${variantName}\";\\n`;\n        output += `  readonly value: ${tsType};\\n`;\n        output += \"}\\n\\n\";\n      }\n    }\n\n    output += `export type ${typeName} = ${variantInterfaces.map(v => v.name).join(\" | \")};\\n\\n`;\n\n    for (const variant of variantInterfaces) {\n      output +=\n        `export function is${variant.name}(value: ${typeName}): value is ${variant.name} {\\n`;\n      output += `  return value.${discriminantField} === \"${variant.discriminatorValue}\";\\n`;\n      output += \"}\\n\\n\";\n    }\n  }\n\n  return output;\n}\n\n/**\n * Generate write types for a specific schema version.\n * All fields are optional in write types.\n */\nfunction generateWriteTypesForVersion(\n  version: number,\n  ir: IRealTimeDocumentSchema,\n): string {\n  const usedRefTypes = detectUsedRefTypes(ir);\n\n  // Collect referenced schema-local types (refs to other records/unions)\n  const referencedLocalTypes = new Set<string>();\n  for (const modelDef of Object.values(ir.models)) {\n    if (modelDef.type !== \"record\") continue;\n    for (const field of modelDef.record.fields) {\n      collectReferencedTypes(field.fieldType, version, referencedLocalTypes);\n    }\n  }\n\n  let output = GENERATED_FILE_HEADER;\n\n  if (usedRefTypes.size > 0) {\n    const refTypesList = Array.from(usedRefTypes).sort().join(\", \");\n    output +=\n      `import type { ${refTypesList} } from \"@palantir/pack.document-schema.model-types\";\\n`;\n  }\n\n  if (referencedLocalTypes.size > 0) {\n    const localTypesList = Array.from(referencedLocalTypes).sort().join(\", \");\n    output += `import type { ${localTypesList} } from \"${typesFilePath(version)}\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record write types\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type !== \"record\") continue;\n\n    const typeName = versionedWriteTypeName(modelKey, version);\n\n    output += `export type ${typeName} = {\\n`;\n\n    for (const field of modelDef.record.fields) {\n      // All fields are optional in write types\n      const tsType = convertFieldTypeToTypeScript(field.fieldType, version);\n      output += `  readonly ${field.key}?: ${tsType};\\n`;\n    }\n\n    output += \"};\\n\\n\";\n  }\n\n  return output;\n}\n\n/**\n * Generate the types.ts re-export file that maps unversioned names to the latest version.\n */\nfunction generateTypesReExport({ ir, version }: VersionedIrEntry): string {\n  const reExports: string[] = [];\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type === \"record\") {\n      const versioned = versionedTypeName(modelKey, version);\n      reExports.push(\n        `export type { ${versioned} as ${modelKey} } from \"${typesFilePath(version)}\";`,\n      );\n    } else if (modelDef.type === \"union\") {\n      const versioned = versionedTypeName(modelKey, version);\n      reExports.push(\n        `export type { ${versioned} as ${modelKey} } from \"${typesFilePath(version)}\";`,\n      );\n\n      // Also re-export union variant types\n      for (const variantName of Object.keys(modelDef.union.variants)) {\n        const formattedVariant = formatVariantName(variantName);\n        const versionedVariant = `${versionedTypeName(modelKey, version)}${formattedVariant}`;\n        const unversionedVariant = `${modelKey}${formattedVariant}`;\n        reExports.push(\n          `export type { ${versionedVariant} as ${unversionedVariant} } from \"${\n            typesFilePath(version)\n          }\";`,\n        );\n      }\n    }\n  }\n\n  return GENERATED_FILE_HEADER + reExports.join(\"\\n\") + \"\\n\";\n}\n\n/**\n * Generate per-version public types and write types from an already-resolved\n * versioned IR chain.\n */\nexport function generateVersionedTypesFromChain(\n  resolved: ResolvedIrChain,\n  minSupportedVersion?: number,\n): VersionedTypesOutput {\n  const { chain } = resolved;\n  const { minVersion } = resolveMinVersion(chain, minSupportedVersion);\n\n  const readTypes = new Map<number, string>();\n  const writeTypes = new Map<number, string>();\n\n  for (const { version, ir } of chain) {\n    if (version < minVersion) continue;\n\n    readTypes.set(version, generateReadTypesForVersion(version, ir));\n    writeTypes.set(version, generateWriteTypesForVersion(version, ir));\n  }\n\n  const typesReExport = generateTypesReExport(chain[chain.length - 1]!);\n\n  return { readTypes, writeTypes, typesReExport };\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,153 @@
+/*
+ * 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 { formatVariantName } from "../formatVariantName.js";
+import { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
+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, ir) {
+  let output = GENERATED_FILE_HEADER;
+
+  // Collect type names for import
+  const typeNames = [];
+  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)}`);
+      }
+    }
+  }
+  output += "import type { ZodType } from \"zod\";\n";
+  output += "import { z } from \"zod\";\n";
+  if (typeNames.length > 0) {
+    output += `import type { ${typeNames.sort().join(", ")} } from "${typesFilePath(version)}";\n`;
+  }
+  output += "\n";
+
+  // Generate record schemas first (unions may depend on them)
+  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 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 [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, variantModelKey] of Object.entries(union.variants)) {
+      const formattedVariant = formatVariantName(variantName);
+      const variantZodSchemaName = `${versionedSchemaName(modelKey, version)}${formattedVariant}`;
+      const variantTypeName = `${versionedTypeName(modelKey, version)}${formattedVariant}`;
+      variantSchemaNames.push(variantZodSchemaName);
+
+      // 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 {
+        // 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: z.lazy((): ZodType<${refTypeName}> => ${refZodSchemaName})\n`;
+        output += `}) satisfies ZodType<${variantTypeName}>;\n\n`;
+      }
+    }
+    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;
+}
+
+/**
+ * Generate the schema.ts re-export file mapping unversioned names to latest version.
+ */
+function generateSchemaReExport({
+  ir,
+  version
+}) {
+  let output = GENERATED_FILE_HEADER;
+  const reExports = [];
+  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(modelDef.union.variants)) {
+        const formattedVariant = formatVariantName(variantName);
+        const versionedVariant = `${versionedSchemaName(modelKey, version)}${formattedVariant}`;
+        reExports.push(`export { ${versionedVariant} as ${`${modelKey}${formattedVariant}Schema`} } from "./schema_v${version}.js";`);
+      }
+    }
+  }
+  output += reExports.join("\n") + "\n";
+  return output;
+}
+
+/**
+ * Generate per-version Zod schemas from an already-resolved versioned IR chain.
+ */
+export function generateVersionedZodFromChain(resolved, minSupportedVersion) {
+  const {
+    chain
+  } = resolved;
+  const {
+    minVersion
+  } = resolveMinVersion(chain, minSupportedVersion);
+  const zodSchemas = new Map();
+  for (const {
+    version,
+    ir
+  } of chain) {
+    if (version < minVersion) continue;
+    zodSchemas.set(version, generateZodSchemasForVersion(version, ir));
+  }
+  const schemaReExport = generateSchemaReExport(chain[chain.length - 1]);
+  return {
+    zodSchemas,
+    schemaReExport
+  };
+}
+//# sourceMappingURL=generateVersionedZodFromSchema.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,52 @@
+/*
+ * 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 { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
+import { resolveMinVersion } from "./resolveSchemaChain.js";
+
+/**
+ * Generate versions.ts from an already-resolved versioned IR chain.
+ *
+ * Output:
+ * ```
+ * export type SupportedVersions = 1 | 2;
+ * export type LatestVersion = 2;
+ * export type MinSupportedVersion = 1;
+ * ```
+ */
+export function generateVersionsFromChain(resolved, minSupportedVersion) {
+  const {
+    chain
+  } = resolved;
+  const {
+    latestVersion,
+    minVersion
+  } = resolveMinVersion(chain, minSupportedVersion);
+  const supportedVersions = [];
+  for (const {
+    version
+  } of chain) {
+    if (version >= minVersion) {
+      supportedVersions.push(version);
+    }
+  }
+  let output = GENERATED_FILE_HEADER;
+  output += `export type SupportedVersions = ${supportedVersions.join(" | ")};\n`;
+  output += `export type LatestVersion = ${latestVersion};\n`;
+  output += `export type MinSupportedVersion = ${minVersion};\n`;
+  return output;
+}
+//# sourceMappingURL=generateVersionsFromSchema.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,104 @@
+/*
+ * 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 { convertSchemaToIr } from "../steps/convertStepsToIr.js";
+
+/**
+ * JSON-serializable form of a single field migration. The `forward` callback
+ * from the schema builder is captured as its source string so the entry can be
+ * round-tripped through a JSON IR file.
+ */
+
+/** Serialized migrations keyed by `[recordModelName][fieldName]`. */
+
+function collectVersionedIrChain(input) {
+  const chain = [];
+  let current = input;
+  while (current.type === "versioned") {
+    chain.unshift({
+      version: current.version,
+      ir: convertSchemaToIr(current.models, {
+        version: current.version
+      }),
+      migrations: serializeMigrations(current.migrations)
+    });
+    current = current.previous;
+  }
+  chain.unshift({
+    version: current.version,
+    ir: convertSchemaToIr(current.models, {
+      version: current.version
+    })
+  });
+  return chain;
+}
+
+/**
+ * Capture each `forward` callback as its source string so the migrations object
+ * is plain JSON-serializable data.
+ */
+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],
+        forwardSource: migration.forward.toString()
+      };
+    }
+    result[modelKey] = fieldEntries;
+  }
+  return result;
+}
+
+/**
+ * Validate `minSupportedVersion` against an already-resolved chain and return
+ * the effective `minVersion`. Throws on invalid input.
+ */
+export function resolveMinVersion(chain, minSupportedVersion) {
+  if (chain.length === 0) {
+    throw new Error("Schema version chain is empty");
+  }
+  const latestVersion = chain[chain.length - 1].version;
+  if (minSupportedVersion != null && !chain.some(c => c.version === minSupportedVersion)) {
+    throw new Error(`minSupportedVersion ${minSupportedVersion} is not in the schema chain ` + `(available versions: ${chain.map(c => c.version).join(", ")})`);
+  }
+  return {
+    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
+  };
+}
+//# sourceMappingURL=resolveSchemaChain.js.map