@amritk/mjst 0.1.0 → 0.2.1

package/README.md

@@ -68,7 +68,8 @@ npx mjst --config ./mjst.config.json
 | 🏷️ | `typesOnly` | `--types-only` | `boolean` | — | `false` | Generate only TypeScript type definitions without parser functions. Useful when you only need the type shapes and do not need runtime validation. |
 | 🔨 | `build` | `--build` | `boolean` | — | `false` | Compile the generated TypeScript files to .js and .d.ts output. A temporary tsconfig is written to the output directory, tsc is invoked, and the intermediate .ts source files are removed when compilation succeeds. |
 | ⚠️ | `logWarnings` | `--log-warnings` | `boolean` | — | `false` | Emit a console.warn in the generated parsers for every input key that is not declared in the schema's properties. Useful for detecting schema drift or unexpected data shapes at runtime. |
-| ⚙️ | `config` | `--config <path>` | `string` | — | — | Path to a JSON config file. Keys match the option names in this schema (schema, outDir, typesOnly, build, logWarnings). CLI flags take precedence over config file values. |
+| 🚫 | `strict` | `--strict` | `boolean` | — | `false` | Generate parsers that throw on type/shape mismatches (wrong type, missing required property, enum/pattern/min/max violations) instead of coercing invalid input to default values. Unknown extra keys are still allowed. |
+| ⚙️ | `config` | `--config <path>` | `string` | — | — | Path to a JSON config file. Keys match the option names in this schema (schema, outDir, typesOnly, build, logWarnings, strict). CLI flags take precedence over config file values. |
 <!-- config-table-end -->
 
 ---

package/dist/cli-config.d.ts

@@ -22,4 +22,10 @@ export type CliConfig = {
      * that is not declared in the schema's properties.
      */
     readonly logWarnings?: boolean;
+    /**
+     * When true, the generated parsers throw on type/shape mismatches
+     * (wrong type, missing required property, enum/pattern/min/max violations)
+     * instead of coercing invalid input to default values.
+     */
+    readonly strict?: boolean;
 };

package/dist/cli.js

@@ -1122,6 +1122,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 +1788,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 +1818,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 +1854,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 +1907,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 +2051,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 +2061,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 +2082,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 +2099,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 +2154,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 +2176,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 +2292,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);
@@ -2236,7 +2397,8 @@ var generateFile = (schema, typeName, options) => {
   }
   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}
@@ -2277,7 +2439,7 @@ var extractDynamicAnchorDefs = (schema) => {
   }
   return refs;
 };
-var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings) => {
+var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict) => {
   rootSchema = upgradeDraft07Schema(rootSchema);
   const files = [];
   const processedRefs = new Set;
@@ -2289,7 +2451,8 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
   const rootContent = generateFile(extendedRootSchema, rootTypeName, {
     typesOnly: typesOnly ?? false,
     rootSchema,
-    ...logWarnings !== undefined ? { logWarnings } : {}
+    ...logWarnings !== undefined ? { logWarnings } : {},
+    ...strict !== undefined ? { strict } : {}
   });
   const rootFilename = rootTypeName.toLowerCase();
   processedFilenames.add(rootFilename);
@@ -2320,7 +2483,8 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
       typesOnly: typesOnly ?? false,
       selfRef: ref,
       rootSchema,
-      ...logWarnings !== undefined ? { logWarnings } : {}
+      ...logWarnings !== undefined ? { logWarnings } : {},
+      ...strict !== undefined ? { strict } : {}
     });
     if (!processedFilenames.has(filename)) {
       processedFilenames.add(filename);
@@ -2385,7 +2549,8 @@ 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"] }
   };
 };
 
@@ -2411,6 +2576,8 @@ var parseCliArgs = (args) => {
         config.build = value !== "false";
       } else if (key === "log-warnings") {
         config.logWarnings = value !== "false";
+      } else if (key === "strict") {
+        config.strict = value !== "false";
       }
       continue;
     }
@@ -2432,6 +2599,8 @@ var parseCliArgs = (args) => {
       config.build = true;
     } else if (arg === "--log-warnings") {
       config.logWarnings = true;
+    } else if (arg === "--strict") {
+      config.strict = true;
     }
   }
   return config;
@@ -2468,7 +2637,7 @@ var run = async () => {
   const schemaPath = resolve2(config.schema);
   const raw = await readFile2(schemaPath, "utf-8");
   const schema = JSON.parse(raw);
-  const files = await buildSchema(schema, "Document", undefined, config.typesOnly, config.logWarnings);
+  const files = await buildSchema(schema, "Document", undefined, config.typesOnly, config.logWarnings, config.strict);
   const outputDir = resolve2(config.outDir);
   await mkdir(outputDir, { recursive: true });
   for (const file of files) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/mjst",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "type": "module",
   "license": "MIT",
@@ -29,6 +29,9 @@
   "files": [
     "dist"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "dev": "bun run --conditions=development ./src/cli.ts",
     "start": "bun run ./src/cli.ts",