@amritk/mjst 0.1.0 → 0.3.0

package/dist/cli.js

@@ -2,12 +2,14 @@
 
 // src/cli.ts
 import { execFile } from "node:child_process";
-import { mkdir, readFile as readFile2, unlink, writeFile } from "node:fs/promises";
-import { dirname, join, relative, resolve as resolve2 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdir, readFile as readFile3, unlink, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join, resolve as resolve3 } from "node:path";
 import { promisify } from "node:util";
 
 // ../generate-parsers/dist/index.js
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, resolve as resolvePath } from "node:path";
 var isSchemaObject = (schema) => {
   return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
 };
@@ -783,21 +785,43 @@ var generateTypeDefinition = (schema, typeName) => {
   }
   return "export type " + typeName + " = unknown;";
 };
-var collectHelpers = (parserFunction) => {
+var PACKAGE_IMPORTS = {
+  "is-object": "import { isObject } from '@amritk/helpers/is-object';",
+  "validate-array": "import { validateArray } from '@amritk/helpers/validate-array';",
+  "validate-record": "import { validateRecord } from '@amritk/helpers/validate-record';",
+  "has-ref": "import { hasRef } from '@amritk/helpers/schema-guards';"
+};
+var EMBEDDED_IMPORTS = {
+  "is-object": "import { isObject } from './_helpers/is-object';",
+  "validate-array": "import { validateArray } from './_helpers/validate-array';",
+  "validate-record": "import { validateRecord } from './_helpers/validate-record';",
+  "has-ref": "import { hasRef } from './_helpers/has-ref';"
+};
+var collectHelpers = (parserFunction, mode) => {
   const imports = [];
+  const used = new Set;
+  const table = mode === "embedded" ? EMBEDDED_IMPORTS : PACKAGE_IMPORTS;
   if (parserFunction.includes("validateArray")) {
-    imports.push("import { validateArray } from '@amritk/helpers/validate-array';");
+    imports.push(table["validate-array"]);
+    used.add("validate-array");
   }
   if (parserFunction.includes("validateRecord")) {
-    imports.push("import { validateRecord } from '@amritk/helpers/validate-record';");
+    imports.push(table["validate-record"]);
+    used.add("validate-record");
+    used.add("is-object");
   }
   if (parserFunction.includes("isObject")) {
-    imports.push("import { isObject } from '@amritk/helpers/is-object';");
+    imports.push(table["is-object"]);
+    used.add("is-object");
   }
   if (parserFunction.includes("hasRef(")) {
-    imports.push("import { hasRef } from '@amritk/helpers/schema-guards';");
+    imports.push(table["has-ref"]);
+    used.add("has-ref");
   }
-  return imports;
+  return { imports, used };
+};
+var hasRef = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "$ref" in value && typeof value.$ref === "string";
 };
 var isSchemaObject3 = (schema) => {
   return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
@@ -880,9 +904,6 @@ var hasMinProperties = (schema) => {
 var hasMaxProperties = (schema) => {
   return isSchemaObject3(schema) && "maxProperties" in schema && typeof schema.maxProperties === "number";
 };
-var hasRef = (schema) => {
-  return isSchemaObject3(schema) && "$ref" in schema && typeof schema.$ref === "string";
-};
 var getImportPathForFilename = (filename) => `./${filename}`;
 var collectImports = (schema, options) => {
   const typesOnly = options?.typesOnly === true;
@@ -1122,6 +1143,117 @@ var getDefaultValue = (schema) => {
       return "undefined";
   }
 };
+var wrongTypeCondition = (accessor, type) => {
+  switch (type) {
+    case "string":
+      return `typeof ${accessor} !== "string"`;
+    case "number":
+    case "integer":
+      return `typeof ${accessor} !== "number"`;
+    case "boolean":
+      return `typeof ${accessor} !== "boolean"`;
+    case "array":
+      return `!Array.isArray(${accessor})`;
+    case "object":
+      return `!isObject(${accessor})`;
+    default:
+      return null;
+  }
+};
+var typeLabel = (type) => type === "integer" ? "number" : type;
+var escapeRegexPattern = (pattern) => {
+  return pattern.replace(/\\/g, "\\\\").replace(/\//g, "\\/");
+};
+var generateConstraintChecks = (acc, propSchema, typeName, key) => {
+  if (!isSchemaObject3(propSchema) || !hasType(propSchema))
+    return [];
+  const t = propSchema.type;
+  const lines = [];
+  if (t === "string") {
+    if (hasPattern(propSchema)) {
+      const pattern = escapeRegexPattern(propSchema.pattern);
+      lines.push(`  if (typeof ${acc} === "string" && !/${pattern}/.test(${acc})) throw new Error('[${typeName}] field "${key}" must match pattern ${propSchema.pattern}');`);
+    }
+    if (hasMinLength(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "string" && ${acc}.length < ${propSchema.minLength}) throw new Error('[${typeName}] field "${key}" must have at least ${propSchema.minLength} characters');`);
+    }
+    if (hasMaxLength(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "string" && ${acc}.length > ${propSchema.maxLength}) throw new Error('[${typeName}] field "${key}" must have at most ${propSchema.maxLength} characters');`);
+    }
+  }
+  if (t === "number" || t === "integer") {
+    if (hasMinimum(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} < ${propSchema.minimum}) throw new Error('[${typeName}] field "${key}" must be >= ${propSchema.minimum}');`);
+    }
+    if (hasMaximum(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} > ${propSchema.maximum}) throw new Error('[${typeName}] field "${key}" must be <= ${propSchema.maximum}');`);
+    }
+    if (hasExclusiveMinimum(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} <= ${propSchema.exclusiveMinimum}) throw new Error('[${typeName}] field "${key}" must be > ${propSchema.exclusiveMinimum}');`);
+    }
+    if (hasExclusiveMaximum(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} >= ${propSchema.exclusiveMaximum}) throw new Error('[${typeName}] field "${key}" must be < ${propSchema.exclusiveMaximum}');`);
+    }
+    if (hasMultipleOf(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} % ${propSchema.multipleOf} !== 0) throw new Error('[${typeName}] field "${key}" must be a multiple of ${propSchema.multipleOf}');`);
+    }
+  }
+  return lines;
+};
+var generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
+  const acc = safeAccessor("input", key);
+  const lines = [];
+  if (isRequired) {
+    lines.push(`  if (!(${JSON.stringify(key)} in input)) throw new Error('[${typeName}] missing required property "${key}"');`);
+  }
+  if (!isSchemaObject3(propSchema))
+    return lines;
+  if (hasRef(propSchema))
+    return lines;
+  if (hasEnum(propSchema)) {
+    const allowed = JSON.stringify(propSchema.enum);
+    const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
+    if (isRequired) {
+      lines.push(`  if (!(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`);
+    } else {
+      lines.push(`  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`);
+    }
+    return lines;
+  }
+  if (hasType(propSchema)) {
+    const t = propSchema.type;
+    const wrongType = wrongTypeCondition(acc, t);
+    if (wrongType) {
+      if (isRequired) {
+        lines.push(`  if (${wrongType}) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+      } else {
+        lines.push(`  if (${acc} !== undefined && (${wrongType})) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+      }
+    }
+    lines.push(...generateConstraintChecks(acc, propSchema, typeName, key));
+  }
+  return lines;
+};
+var generateObjectStrictAssertion = (schema, typeName) => {
+  const lines = [];
+  lines.push(`  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`);
+  if (!hasProperties(schema) || !isSchemaObject3(schema))
+    return lines;
+  const required = new Set(hasRequired(schema) ? schema.required : []);
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    lines.push(...generatePropertyAssertion(key, propSchema, required.has(key), typeName));
+  }
+  return lines;
+};
+var generateScalarStrictAssertion = (schema, typeName) => {
+  if (!isSchemaObject3(schema) || !hasType(schema))
+    return null;
+  const t = schema.type;
+  const wrongType = wrongTypeCondition("input", t);
+  if (!wrongType)
+    return null;
+  return `  if (${wrongType}) throw new Error(\`[${typeName}] expected ${typeLabel(t)}, got \${input === null ? "null" : typeof input}\`);`;
+};
 var findDiscriminator = (schemas) => {
   const propertyValues = new Map;
   for (const schema of schemas) {
@@ -1677,11 +1809,22 @@ var generateFallbackObject = (schema, useRefImports, typeName) => {
       }`;
   return result;
 };
-var generateNonObjectParser = (typeName, schema) => {
+var generateNonObjectParser = (typeName, schema, strict) => {
   const functionName = generateParserName(typeName);
   if (!isSchemaObject3(schema) || !hasType(schema)) {
     return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
   }
+  if (strict) {
+    const assertion = generateScalarStrictAssertion(schema, typeName);
+    if (assertion === null) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
+    }
+    const returnExpr = schema.type === "array" ? `[...(input as readonly unknown[])] as ${typeName}` : `input as ${typeName}`;
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+${assertion}
+  return ${returnExpr};
+};`;
+  }
   switch (schema.type) {
     case "string":
       return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "string" ? input as ${typeName} : "" as ${typeName};`;
@@ -1696,8 +1839,14 @@ var generateNonObjectParser = (typeName, schema) => {
       return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
   }
 };
-var generateEmptyObjectParser = (typeName) => {
+var generateEmptyObjectParser = (typeName, strict) => {
   const functionName = generateParserName(typeName);
+  if (strict) {
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return { ...input } as ${typeName};
+};`;
+  }
   return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {} as ${typeName};`;
 };
 var toVarName = (key) => {
@@ -1726,7 +1875,7 @@ var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
     case "string": {
       checks.push(`typeof ${varName} === "string"`);
       if (hasPattern(schema))
-        checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${varName})`);
+        checks.push(`/${escapeRegexPattern2(schema.pattern)}/.test(${varName})`);
       if (hasMinLength(schema))
         checks.push(`${varName}.length >= ${schema.minLength}`);
       if (hasMaxLength(schema))
@@ -1779,16 +1928,28 @@ var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
 var shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
   return isSchemaObject3(propSchema);
 };
-var generateObjectParser = (schema, typeName, useRefImports, logWarnings) => {
+var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict) => {
   const functionName = generateParserName(typeName);
   if (!hasProperties(schema)) {
+    if (strict) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return input as ${typeName};
+};`;
+    }
     return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
   }
   const fallbackObject = generateFallbackObject(schema, useRefImports, typeName);
   const properties = Object.entries(schema.properties);
   const lines = [];
   lines.push(`export const ${functionName} = (input: unknown): ${typeName} => {`);
-  lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
+  if (strict) {
+    for (const assertionLine of generateObjectStrictAssertion(schema, typeName)) {
+      lines.push(assertionLine);
+    }
+  } else {
+    lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
+  }
   const propInfo = [];
   const hasAllOfRefParsers = useRefImports && isSchemaObject3(schema) && hasAllOf(schema) && schema.allOf.some((entry) => isSchemaObject3(entry) && hasRef(entry));
   let canFastPath = !hasAllOfRefParsers;
@@ -1911,7 +2072,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings) => {
   }
   return result;
 };
-var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings) => {
+var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings, strict) => {
   const functionName = generateParserName(typeName);
   const entries = generatePropertyEntries(schema, useRefImports);
   const propertyLines = entries.map((entry) => {
@@ -1921,19 +2082,19 @@ var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings
     return `    ${safeKey2(entry.key)}: ${entry.value},`;
   });
   if (!isSchemaObject3(schema) || !("patternProperties" in schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings);
+    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict);
   }
   const patternProps = schema.patternProperties;
   const patterns = Object.entries(patternProps);
   const refPattern = patterns.find(([, ps]) => isSchemaObject3(ps) && hasRef(ps));
   if (!refPattern || !useRefImports) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings);
+    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict);
   }
   const [pattern, patternSchema] = refPattern;
   const ref = patternSchema.$ref;
   const parserName = generateParserName(refToName(ref));
   const assignmentCode = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
-  const escapedPattern = escapeRegexPattern(pattern);
+  const escapedPattern = escapeRegexPattern2(pattern);
   const inputSpread = "    ...input,";
   let objectProperties = inputSpread;
   if (propertyLines.length > 0) {
@@ -1942,9 +2103,10 @@ var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings
 ` + line;
     }
   }
+  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
   return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
-    return {} as unknown as ${typeName};
+${notObjectBranch}
   }
   const result = {
 ${objectProperties}
@@ -1958,23 +2120,41 @@ ${objectProperties}
   return result;
 };`;
 };
-var generateAdditionalPropertiesParser = (schema, typeName, useRefImports) => {
+var generateAdditionalPropertiesParser = (schema, typeName, useRefImports, strict) => {
   const functionName = generateParserName(typeName);
   const additionalProps = schema.additionalProperties;
   if (!additionalProps) {
-    return generateEmptyObjectParser(typeName);
+    return generateEmptyObjectParser(typeName, strict);
   }
   if (useRefImports && isSchemaObject3(additionalProps) && hasRef(additionalProps)) {
     const ref = additionalProps.$ref;
     const parserName = generateParserName(refToName(ref));
+    if (strict) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return validateRecord(input, ${parserName}) as ${typeName};
+};`;
+    }
     return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${parserName}) as ${typeName};`;
   }
   if (isSchemaObject3(additionalProps) && hasType(additionalProps)) {
     const inlineParser = generateInlineValueParser(additionalProps);
     if (inlineParser) {
+      if (strict) {
+        return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return validateRecord(input, ${inlineParser}) as ${typeName};
+};`;
+      }
       return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${inlineParser}) as ${typeName};`;
     }
   }
+  if (strict) {
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return { ...input } as ${typeName};
+};`;
+  }
   return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {};`;
 };
 var generateInlineValueParser = (schema) => {
@@ -1995,18 +2175,18 @@ var generateInlineValueParser = (schema) => {
       return null;
   }
 };
-var escapeRegexPattern = (pattern) => {
+var escapeRegexPattern2 = (pattern) => {
   return pattern.replace(/\\/g, "\\\\").replace(/\//g, "\\/");
 };
-var generatePatternPropertiesParser = (schema, typeName, useRefImports) => {
+var generatePatternPropertiesParser = (schema, typeName, useRefImports, strict) => {
   const functionName = generateParserName(typeName);
   if (!("patternProperties" in schema) || typeof schema.patternProperties !== "object") {
-    return generateEmptyObjectParser(typeName);
+    return generateEmptyObjectParser(typeName, strict);
   }
   const patternProps = schema.patternProperties;
   const patterns = Object.entries(patternProps);
   if (patterns.length === 0) {
-    return generateEmptyObjectParser(typeName);
+    return generateEmptyObjectParser(typeName, strict);
   }
   const [pattern, patternSchema] = patterns[0];
   let patternAssignment = "(result as Record<string, unknown>)[key] = value;";
@@ -2017,10 +2197,11 @@ var generatePatternPropertiesParser = (schema, typeName, useRefImports) => {
   } else if (patternSchema === false) {
     patternAssignment = "";
   }
-  const escapedPattern = escapeRegexPattern(pattern);
+  const escapedPattern = escapeRegexPattern2(pattern);
+  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
   return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
-    return {} as unknown as ${typeName};
+${notObjectBranch}
   }
   const result = {
     ...input,
@@ -2132,43 +2313,44 @@ var generateSchemaObjectParser = (typeName) => {
 var selectParserStrategy = (schema, typeName, options) => {
   const useRefImports = options?.useRefImports ?? false;
   const logWarnings = options?.logWarnings ?? false;
+  const strict = options?.strict ?? false;
   if (typeName === "SchemaObject") {
     return generateSchemaObjectParser(typeName);
   }
   const isObjectLikeSchema2 = isObjectSchema2(schema) || isSchemaObject3(schema) && (("patternProperties" in schema) || ("additionalProperties" in schema));
   if (!isObjectLikeSchema2 && !isSchemaObject3(schema)) {
-    return generateNonObjectParser(typeName, schema);
+    return generateNonObjectParser(typeName, schema, strict);
   }
   if (hasProperties(schema) && isSchemaObject3(schema) && "patternProperties" in schema) {
-    return generateCombinedObjectParser(schema, typeName, useRefImports, logWarnings);
+    return generateCombinedObjectParser(schema, typeName, useRefImports, logWarnings, strict);
   }
   if (hasProperties(schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings);
+    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict);
   }
   if (isSchemaObject3(schema) && "if" in schema && "then" in schema && "else" in schema) {
     return generateConditionalParser(schema, typeName);
   }
   const conditionalObjectSchema = getConditionalObjectSchema2(schema);
   if (conditionalObjectSchema) {
-    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, logWarnings);
+    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, logWarnings, strict);
   }
   if (!isObjectLikeSchema2) {
-    return generateNonObjectParser(typeName, schema);
+    return generateNonObjectParser(typeName, schema, strict);
   }
   if ("patternProperties" in schema) {
-    return generatePatternPropertiesParser(schema, typeName, useRefImports);
+    return generatePatternPropertiesParser(schema, typeName, useRefImports, strict);
   }
   if ("additionalProperties" in schema && !hasProperties(schema)) {
     const additionalProps = schema.additionalProperties;
     if (additionalProps === true || additionalProps === false) {
-      return generateEmptyObjectParser(typeName);
+      return generateEmptyObjectParser(typeName, strict);
     }
-    return generateAdditionalPropertiesParser(schema, typeName, useRefImports);
+    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, strict);
   }
   if ("type" in schema && schema.type === "object" && !hasProperties(schema)) {
-    return generateEmptyObjectParser(typeName);
+    return generateEmptyObjectParser(typeName, strict);
   }
-  return generateEmptyObjectParser(typeName);
+  return generateEmptyObjectParser(typeName, strict);
 };
 var generateParserFunction = (schema, typeName, options) => {
   return selectParserStrategy(schema, typeName, options);
@@ -2218,6 +2400,7 @@ var generateFile = (schema, typeName, options) => {
   const typesOnly = options?.typesOnly === true;
   const selfRef = options?.selfRef;
   const rootSchema = options?.rootSchema;
+  const helpersMode = options?.helpersMode ?? "package";
   const typeDefinition = generateTypeDefinition(schema, typeName);
   if (typesOnly) {
     const imports2 = collectImports(schema, { typesOnly: true, selfRef, rootSchema });
@@ -2232,17 +2415,19 @@ var generateFile = (schema, typeName, options) => {
 
 `;
     }
-    return result2 + typeDefinition;
+    return { content: result2 + typeDefinition, usedHelpers: new Set };
   }
   const parserFunction = generateParserFunction(schema, typeName, {
     useRefImports: true,
-    ...options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {}
+    ...options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {},
+    ...options?.strict !== undefined ? { strict: options.strict } : {}
   });
   const shapeValidator = generateShapeValidator(schema, typeName, true);
   const combinedFunctions = `${shapeValidator}
 
 ${parserFunction}`;
-  const imports = [...collectImports(schema, { selfRef, rootSchema }), ...collectHelpers(combinedFunctions)];
+  const helpers = collectHelpers(combinedFunctions, helpersMode);
+  const imports = [...collectImports(schema, { selfRef, rootSchema }), ...helpers.imports];
   let result = "";
   if (imports.length > 0) {
     result += imports[0];
@@ -2254,9 +2439,15 @@ ${parserFunction}`;
 
 `;
   }
-  return result + typeDefinition + `
+  return { content: result + typeDefinition + `
 
-` + combinedFunctions;
+` + combinedFunctions, usedHelpers: helpers.used };
+};
+var readHelperSource = async (helper) => {
+  const require2 = createRequire(import.meta.url);
+  const helpersPkgPath = require2.resolve("@amritk/helpers/package.json");
+  const helpersRoot = dirname(helpersPkgPath);
+  return readFile(resolvePath(helpersRoot, "src", `${helper}.ts`), "utf-8");
 };
 var extractDynamicAnchorDefs = (schema) => {
   const refs = [];
@@ -2277,26 +2468,31 @@ var extractDynamicAnchorDefs = (schema) => {
   }
   return refs;
 };
-var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings) => {
+var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = "package") => {
   rootSchema = upgradeDraft07Schema(rootSchema);
   const files = [];
   const processedRefs = new Set;
   const processedFilenames = new Set;
   const refsToProcess = [];
+  const usedHelpers = new Set;
   const dynamicRefMap = buildDynamicRefMap(rootSchema);
   const processedRootSchema = resolveDynamicRefs(rootSchema, dynamicRefMap);
   const extendedRootSchema = extensions ? applySchemaExtensions(processedRootSchema, rootTypeName.toLowerCase(), extensions) : processedRootSchema;
-  const rootContent = generateFile(extendedRootSchema, rootTypeName, {
+  const rootResult = generateFile(extendedRootSchema, rootTypeName, {
     typesOnly: typesOnly ?? false,
     rootSchema,
-    ...logWarnings !== undefined ? { logWarnings } : {}
+    helpersMode,
+    ...logWarnings !== undefined ? { logWarnings } : {},
+    ...strict !== undefined ? { strict } : {}
   });
   const rootFilename = rootTypeName.toLowerCase();
   processedFilenames.add(rootFilename);
   files.push({
     filename: `${rootFilename}.ts`,
-    content: rootContent
+    content: rootResult.content
   });
+  for (const helper of rootResult.usedHelpers)
+    usedHelpers.add(helper);
   const rootRefs = extractRefs(rootSchema);
   refsToProcess.push(...rootRefs);
   const dynamicAnchorRefs = extractDynamicAnchorDefs(rootSchema);
@@ -2316,19 +2512,23 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
     const filename = refToFilename(ref);
     const processedSchema = resolveDynamicRefs(resolvedSchema, dynamicRefMap);
     const extendedSchema = extensions ? applySchemaExtensions(processedSchema, filename, extensions) : processedSchema;
-    const content = generateFile(extendedSchema, typeName, {
+    const fileResult = generateFile(extendedSchema, typeName, {
       typesOnly: typesOnly ?? false,
       selfRef: ref,
       rootSchema,
-      ...logWarnings !== undefined ? { logWarnings } : {}
+      helpersMode,
+      ...logWarnings !== undefined ? { logWarnings } : {},
+      ...strict !== undefined ? { strict } : {}
     });
     if (!processedFilenames.has(filename)) {
       processedFilenames.add(filename);
       files.push({
         filename: `${filename}.ts`,
-        content
+        content: fileResult.content
       });
     }
+    for (const helper of fileResult.usedHelpers)
+      usedHelpers.add(helper);
     const nestedRefs = extractRefs(resolvedSchema);
     for (const nestedRef of nestedRefs) {
       if (!processedRefs.has(nestedRef)) {
@@ -2336,9 +2536,15 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
       }
     }
   }
+  if (helpersMode === "embedded" && !typesOnly) {
+    for (const helper of usedHelpers) {
+      const source = await readHelperSource(helper);
+      files.push({ filename: `_helpers/${helper}.ts`, content: source });
+    }
+  }
   const TYPE_EXPORT_RE = /^export type (\w+)/gm;
   const CONST_EXPORT_RE = /^export const (\w+)/gm;
-  const sortedFiles = [...files].sort((a, b) => a.filename.localeCompare(b.filename));
+  const sortedFiles = [...files].filter((f) => !f.filename.startsWith("_helpers/")).sort((a, b) => a.filename.localeCompare(b.filename));
   let indexContent = "";
   for (const file of sortedFiles) {
     const moduleName = file.filename.replace(/\.ts$/, "");
@@ -2369,12 +2575,25 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
   return files;
 };
 
-// src/load-config.ts
-import { readFile } from "node:fs/promises";
+// src/detect-helpers-mode.ts
+import { createRequire as createRequire2 } from "node:module";
 import { resolve } from "node:path";
+var detectHelpersMode = (outputDir) => {
+  const req = createRequire2(resolve(outputDir, "noop.js"));
+  try {
+    req.resolve("@amritk/helpers/is-object");
+    return "package";
+  } catch {
+    return "embedded";
+  }
+};
+
+// src/load-config.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
 var loadConfig = async (configPath) => {
-  const absolutePath = resolve(configPath);
-  const raw = await readFile(absolutePath, "utf-8");
+  const absolutePath = resolve2(configPath);
+  const raw = await readFile2(absolutePath, "utf-8");
   const parsed = JSON.parse(raw);
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new Error(`Config file must be a JSON object: ${configPath}`);
@@ -2385,13 +2604,19 @@ var loadConfig = async (configPath) => {
     ...typeof obj["outDir"] === "string" && { outDir: obj["outDir"] },
     ...typeof obj["typesOnly"] === "boolean" && { typesOnly: obj["typesOnly"] },
     ...typeof obj["build"] === "boolean" && { build: obj["build"] },
-    ...typeof obj["logWarnings"] === "boolean" && { logWarnings: obj["logWarnings"] }
+    ...typeof obj["logWarnings"] === "boolean" && { logWarnings: obj["logWarnings"] },
+    ...typeof obj["strict"] === "boolean" && { strict: obj["strict"] }
   };
 };
 
 // src/parse-cli-args.ts
 var parseCliArgs = (args) => {
   const config = {};
+  const parseHelpersValue = (value) => {
+    if (value === "package" || value === "embedded")
+      return value;
+    return;
+  };
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (!arg) {
@@ -2411,6 +2636,12 @@ var parseCliArgs = (args) => {
         config.build = value !== "false";
       } else if (key === "log-warnings") {
         config.logWarnings = value !== "false";
+      } else if (key === "strict") {
+        config.strict = value !== "false";
+      } else if (key === "helpers") {
+        const parsed = parseHelpersValue(value);
+        if (parsed)
+          config.helpers = parsed;
       }
       continue;
     }
@@ -2432,6 +2663,17 @@ var parseCliArgs = (args) => {
       config.build = true;
     } else if (arg === "--log-warnings") {
       config.logWarnings = true;
+    } else if (arg === "--strict") {
+      config.strict = true;
+    } else if (arg === "--helpers") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("--")) {
+        const parsed = parseHelpersValue(value);
+        if (parsed) {
+          config.helpers = parsed;
+          i++;
+        }
+      }
     }
   }
   return config;
@@ -2465,21 +2707,21 @@ var run = async () => {
     console.error("Error: --outDir is required. Provide an output directory for generated files.");
     process.exit(1);
   }
-  const schemaPath = resolve2(config.schema);
-  const raw = await readFile2(schemaPath, "utf-8");
+  const schemaPath = resolve3(config.schema);
+  const raw = await readFile3(schemaPath, "utf-8");
   const schema = JSON.parse(raw);
-  const files = await buildSchema(schema, "Document", undefined, config.typesOnly, config.logWarnings);
-  const outputDir = resolve2(config.outDir);
+  const outputDir = resolve3(config.outDir);
   await mkdir(outputDir, { recursive: true });
+  const helpersMode = config.helpers ?? detectHelpersMode(outputDir);
+  console.log(`Helpers mode: ${helpersMode}${config.helpers ? " (explicit)" : " (auto-detected)"}`);
+  const files = await buildSchema(schema, "Document", undefined, config.typesOnly, config.logWarnings, config.strict, helpersMode);
   for (const file of files) {
     const filePath = join(outputDir, file.filename);
-    await mkdir(dirname(filePath), { recursive: true });
+    await mkdir(dirname2(filePath), { recursive: true });
     await writeFile(filePath, file.content, "utf-8");
     console.log(`Generated: ${file.filename}`);
   }
   if (config.build) {
-    const helpersDir = resolve2(dirname(fileURLToPath(import.meta.url)), "../../helpers/dist");
-    const helpersRelative = relative(outputDir, helpersDir);
     const tsconfigContent = JSON.stringify({
       compilerOptions: {
         target: "ESNext",
@@ -2487,10 +2729,7 @@ var run = async () => {
         moduleResolution: "bundler",
         declaration: true,
         emitDeclarationOnly: config.typesOnly,
-        skipLibCheck: true,
-        paths: {
-          "@amritk/helpers/*": [`${helpersRelative}/*`]
-        }
+        skipLibCheck: true
       },
       include: ["./**/*.ts"]
     }, null, 2);