@amritk/generate-parsers 0.12.2 → 0.13.0

package/dist/generators/generate-type-checks.js

@@ -0,0 +1,370 @@
+import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
+import { multipleOfPassExpr } from '@amritk/helpers/multiple-of-check';
+import { refToName } from '@amritk/helpers/ref-to-name';
+import { resolveRef } from '@amritk/helpers/resolve-ref';
+import { safeAccessor } from '@amritk/helpers/safe-accessor';
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { generateEnumCheck } from './generate-enum-check.js';
+import { scalarItemTypeCheck } from './generate-validation-expression.js';
+/**
+ * Boolean type-check expression builders shared by the shape validators, the
+ * parsers' fast paths, and the strict-mode assertions. They live in their own
+ * module (rather than generate-parser-function) so generate-strict-assertion
+ * can use them without an import cycle.
+ *
+ * Every expression built here is *true-sound*: when it evaluates to true the
+ * value definitely matches the schema fragment. That is all a fast path needs.
+ * The reverse direction — false definitely means invalid — only holds when
+ * {@link canEnforceUnion} approves the schema, because a check may call an
+ * imported `validate{X}Shape` that was generated as a conservative `=> false`
+ * stub. Strict-mode code that *throws* on a false check must gate on it.
+ */
+/**
+ * Returns the shape-predicate function name for a given type name.
+ * The predicate is generated alongside each parser and tells callers
+ * whether `input` is already in the shape produced by the parser's fast path.
+ */
+export const shapeValidatorName = (typeName) => `validate${typeName}Shape`;
+/**
+ * Extracts the branch list of a `oneOf`/`anyOf` union, or `null` when the
+ * schema is not a union (or mixes in other composition keywords we cannot
+ * turn into a membership check).
+ */
+export const getUnionBranches = (schema) => {
+    if (!isSchemaObject(schema))
+        return null;
+    if (hasAllOf(schema) || 'not' in schema)
+        return null;
+    if (hasOneOf(schema) && schema.oneOf.length > 0)
+        return schema.oneOf;
+    if (hasAnyOf(schema) && schema.anyOf.length > 0)
+        return schema.anyOf;
+    return null;
+};
+/**
+ * Generates a fast-path type check expression for a property.
+ * Returns null if the schema is too complex for a simple type check.
+ *
+ * When `useRefImports` is true, $ref properties (and arrays of $refs) are
+ * checked by calling the imported shape predicate, allowing parent parsers
+ * to fast-path through nested ref types without recursing into their parsers.
+ */
+export const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
+    if (!isSchemaObject(schema))
+        return null;
+    // $ref via shape predicate (deep fast-path through nested types).
+    if (useRefImports && hasRef(schema)) {
+        const refName = refToName(schema.$ref, suffix);
+        return `${shapeValidatorName(refName)}(${varName})`;
+    }
+    if (hasRef(schema))
+        return null;
+    // A fixed member set is directly predicable regardless of `type` — this is
+    // what lets a nested object carrying an enum property (e.g. `axiom.kind`)
+    // keep a real shape validator instead of the `=> false` stub.
+    if (hasEnum(schema)) {
+        return schema.enum.length > 0 ? generateEnumCheck(varName, schema.enum) : null;
+    }
+    // A union property is predicable when every branch is: membership is the
+    // disjunction of the branch checks.
+    const branches = getUnionBranches(schema);
+    if (branches) {
+        return generateUnionCheck(varName, branches, useRefImports, suffix);
+    }
+    // Remaining composition (allOf, not, or a union mixed with them) cannot be
+    // expressed as a simple boolean check.
+    if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || 'not' in schema) {
+        return null;
+    }
+    // A `const` property (the usual discriminated-union tag, e.g. `kind: "lit"`) has
+    // no `type`, but is fast-path predicable via strict equality. Handling it here is
+    // what lets a discriminated branch's shape validator be a real predicate instead
+    // of the `=> false` stub. Structural consts need deep equality, so skip those.
+    if (hasConst(schema)) {
+        const c = schema.const;
+        return c === null || typeof c !== 'object' ? `${varName} === ${JSON.stringify(c)}` : null;
+    }
+    if (!hasType(schema))
+        return null;
+    // Array of $refs: each item must satisfy the imported shape predicate.
+    if (useRefImports &&
+        schema.type === 'array' &&
+        hasItems(schema) &&
+        isSchemaObject(schema.items) &&
+        hasRef(schema.items)) {
+        const refName = refToName(schema.items.$ref, suffix);
+        return `Array.isArray(${varName}) && ${varName}.every(${shapeValidatorName(refName)})`;
+    }
+    const checks = [];
+    switch (schema.type) {
+        case 'string': {
+            checks.push(`typeof ${varName} === "string"`);
+            if (hasPattern(schema))
+                checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${varName})`);
+            if (hasMinLength(schema))
+                checks.push(`${varName}.length >= ${schema.minLength}`);
+            if (hasMaxLength(schema))
+                checks.push(`${varName}.length <= ${schema.maxLength}`);
+            break;
+        }
+        case 'number':
+        case 'integer': {
+            checks.push(`typeof ${varName} === "number"`);
+            // `integer` must reject non-integral numbers on the fast path too, otherwise
+            // `1.5` would pass through uncoerced.
+            if (schema.type === 'integer')
+                checks.push(`Number.isInteger(${varName})`);
+            if (hasMinimum(schema))
+                checks.push(`${varName} >= ${schema.minimum}`);
+            if (hasMaximum(schema))
+                checks.push(`${varName} <= ${schema.maximum}`);
+            if (hasExclusiveMinimum(schema))
+                checks.push(`${varName} > ${schema.exclusiveMinimum}`);
+            if (hasExclusiveMaximum(schema))
+                checks.push(`${varName} < ${schema.exclusiveMaximum}`);
+            if (hasMultipleOf(schema))
+                checks.push(multipleOfPassExpr(varName, schema.multipleOf));
+            break;
+        }
+        case 'boolean':
+            checks.push(`typeof ${varName} === "boolean"`);
+            break;
+        case 'array': {
+            checks.push(`Array.isArray(${varName})`);
+            if (hasMinItems(schema))
+                checks.push(`${varName}.length >= ${schema.minItems}`);
+            if (hasMaxItems(schema))
+                checks.push(`${varName}.length <= ${schema.maxItems}`);
+            if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+                checks.push(`new Set(${varName}).size === ${varName}.length`);
+            }
+            // For a scalar or enum item type, every element must already be well-typed
+            // to take the fast path; a mismatched element routes the array to the slow
+            // path where each element is coerced (or, in strict mode, throws).
+            if (hasItems(schema) && !Array.isArray(schema.items)) {
+                const items = schema.items;
+                const itemCheck = scalarItemTypeCheck(items, '_it') ??
+                    (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0
+                        ? generateEnumCheck('_it', items.enum)
+                        : null);
+                if (itemCheck)
+                    checks.push(`${varName}.every((_it) => ${itemCheck})`);
+            }
+            break;
+        }
+        case 'object':
+            checks.push(`isObject(${varName})`);
+            break;
+        default:
+            return null;
+    }
+    if (checks.length === 0)
+        return null;
+    // checks[0] is safe: we guard with checks.length === 0 above
+    let result = checks[0];
+    for (let i = 1; i < checks.length; i++) {
+        result += ' && ' + checks[i];
+    }
+    return result;
+};
+/**
+ * Generates a boolean check that `varName` matches an inline object schema —
+ * `isObject` plus a per-property check for every declared property (and a
+ * presence check for `required` keys without a declared schema). Used for
+ * union branches written inline, where no named shape validator exists to
+ * call. Returns null when any property is too complex to check.
+ */
+export const generateInlineObjectCheck = (varName, schema, useRefImports, suffix) => {
+    if (!isSchemaObject(schema) || !isObjectSchema(schema) || !hasProperties(schema))
+        return null;
+    if (hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema) || 'not' in schema)
+        return null;
+    if ('patternProperties' in schema || 'if' in schema)
+        return null;
+    // additionalProperties-as-schema (records) would leave the record values
+    // unchecked, breaking the "true means valid" guarantee.
+    if (hasAdditionalProperties(schema) && typeof schema.additionalProperties !== 'boolean')
+        return null;
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const checks = [`isObject(${varName})`];
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+        const acc = safeAccessor(varName, key);
+        const check = generatePropertyTypeCheck(acc, propSchema, useRefImports, suffix);
+        if (check === null)
+            return null;
+        checks.push(required.has(key) ? check : `(${acc} === undefined || ${check})`);
+        required.delete(key);
+    }
+    // `required` keys without a declared property schema still need a presence check.
+    for (const key of required) {
+        checks.push(`${JSON.stringify(key)} in ${varName}`);
+    }
+    // additionalProperties: false — extras make the value invalid for this branch.
+    if (hasAdditionalProperties(schema) && schema.additionalProperties === false) {
+        const allowedKeys = JSON.stringify(Object.keys(schema.properties));
+        checks.push(`Object.keys(${varName}).every((_k) => ${allowedKeys}.includes(_k))`);
+    }
+    return checks.join(' && ');
+};
+/**
+ * Generates a union membership check: true when `varName` matches at least one
+ * branch of a `oneOf`/`anyOf`. Inline object branches get a per-property check;
+ * everything else goes through {@link generatePropertyTypeCheck} ($refs call
+ * the imported shape validator, consts/enums/scalars check directly). Returns
+ * null when any branch cannot be checked.
+ */
+export const generateUnionCheck = (varName, branches, useRefImports, suffix) => {
+    if (branches.length === 0)
+        return null;
+    const parts = [];
+    for (const branch of branches) {
+        if (!isSchemaObject(branch))
+            return null;
+        const check = isObjectSchema(branch) && hasProperties(branch) && !hasRef(branch)
+            ? generateInlineObjectCheck(varName, branch, useRefImports, suffix)
+            : generatePropertyTypeCheck(varName, branch, useRefImports, suffix);
+        if (check === null)
+            return null;
+        parts.push(`(${check})`);
+    }
+    // Callers conjoin this with other checks, so a multi-branch disjunction must
+    // carry its own parentheses — `a || b && c` binds the wrong way without them.
+    return parts.length === 1 ? parts[0] : `(${parts.join(' || ')})`;
+};
+/**
+ * True when the union membership check emitted by {@link generateUnionCheck}
+ * is also *false-sound* — a false result definitely means the value is invalid
+ * — so strict mode may throw on it.
+ *
+ * The risk is `$ref`s: a branch (or a property inside one) whose check calls
+ * an imported `validate{X}Shape` is only trustworthy when that validator was
+ * generated as a real predicate. This walks every reachable ref (mirroring
+ * generateShapeValidator's stub conditions) and rejects the union when any of
+ * them would have produced the conservative `=> false` stub, or is itself
+ * built on one. Cycles (e.g. a recursive `expr` union) are assumed sound —
+ * the recursion bottoms out on the data, not the schema.
+ */
+export const canEnforceUnion = (branches, rootSchema) => {
+    const visiting = new Set();
+    return (branches.length > 0 &&
+        branches.every((branch) => {
+            if (!isSchemaObject(branch))
+                return false;
+            return isObjectSchema(branch) && hasProperties(branch) && !hasRef(branch)
+                ? canTrustInlineObjectCheck(branch, rootSchema, visiting)
+                : canTrustPropertyCheck(branch, rootSchema, visiting);
+        }));
+};
+/** Mirrors {@link generatePropertyTypeCheck}: non-null AND every embedded validator call is real. */
+const canTrustPropertyCheck = (schema, rootSchema, visiting) => {
+    if (!isSchemaObject(schema))
+        return false;
+    if (hasRef(schema)) {
+        return canTrustReferencedValidator(schema.$ref, rootSchema, visiting);
+    }
+    if (hasEnum(schema))
+        return schema.enum.length > 0;
+    const branches = getUnionBranches(schema);
+    if (branches) {
+        return branches.every((branch) => {
+            if (!isSchemaObject(branch))
+                return false;
+            return isObjectSchema(branch) && hasProperties(branch) && !hasRef(branch)
+                ? canTrustInlineObjectCheck(branch, rootSchema, visiting)
+                : canTrustPropertyCheck(branch, rootSchema, visiting);
+        });
+    }
+    if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || 'not' in schema)
+        return false;
+    if (hasConst(schema))
+        return schema.const === null || typeof schema.const !== 'object';
+    if (!hasType(schema))
+        return false;
+    if (schema.type === 'array' && hasItems(schema) && isSchemaObject(schema.items) && hasRef(schema.items)) {
+        return canTrustReferencedValidator(schema.items.$ref, rootSchema, visiting);
+    }
+    switch (schema.type) {
+        case 'string':
+        case 'number':
+        case 'integer':
+        case 'boolean':
+        case 'array':
+        case 'object':
+            return true;
+        default:
+            return false;
+    }
+};
+/** Mirrors {@link generateInlineObjectCheck}: non-null AND every property check is trustworthy. */
+const canTrustInlineObjectCheck = (schema, rootSchema, visiting) => {
+    if (!isSchemaObject(schema) || !isObjectSchema(schema) || !hasProperties(schema))
+        return false;
+    if (hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema) || 'not' in schema)
+        return false;
+    if ('patternProperties' in schema || 'if' in schema)
+        return false;
+    if (hasAdditionalProperties(schema) && typeof schema.additionalProperties !== 'boolean')
+        return false;
+    return Object.values(schema.properties).every((propSchema) => canTrustPropertyCheck(propSchema, rootSchema, visiting));
+};
+/**
+ * True when the file generated for `ref`'s target carries a *real* (non-stub)
+ * shape validator whose result can be trusted in both directions. Mirrors the
+ * schema classes generateShapeValidator (and its new union/alias paths) turns
+ * into real predicates, recursing into every reachable ref.
+ */
+const canTrustReferencedValidator = (ref, rootSchema, visiting) => {
+    if (visiting.has(ref))
+        return true;
+    if (!rootSchema)
+        return false;
+    const resolved = resolveRef(ref, rootSchema);
+    if (!resolved || !isSchemaObject(resolved))
+        return false;
+    visiting.add(ref);
+    try {
+        // Alias definition (bare $ref): its validator delegates to the target's.
+        if (hasRef(resolved) && !hasProperties(resolved)) {
+            return canTrustReferencedValidator(resolved.$ref, rootSchema, visiting);
+        }
+        // Pure union definition: real when the membership check is enforceable.
+        if (!hasProperties(resolved)) {
+            const branches = getUnionBranches(resolved);
+            if (!branches)
+                return false;
+            if ('patternProperties' in resolved || 'if' in resolved)
+                return false;
+            return branches.every((branch) => {
+                if (!isSchemaObject(branch))
+                    return false;
+                return isObjectSchema(branch) && hasProperties(branch) && !hasRef(branch)
+                    ? canTrustInlineObjectCheck(branch, rootSchema, visiting)
+                    : canTrustPropertyCheck(branch, rootSchema, visiting);
+            });
+        }
+        // Object definition: real when generateShapeValidator emits a predicate —
+        // no composition/conditional keywords, and every property check resolves.
+        if (hasOneOf(resolved) ||
+            hasAnyOf(resolved) ||
+            hasAllOf(resolved) ||
+            'not' in resolved ||
+            'patternProperties' in resolved ||
+            'if' in resolved ||
+            'then' in resolved ||
+            'else' in resolved) {
+            return false;
+        }
+        return Object.values(resolved.properties).every((propSchema) => {
+            // Records of refs make generateShapeValidator bail to the stub.
+            if (isSchemaObject(propSchema) &&
+                hasAdditionalProperties(propSchema) &&
+                typeof propSchema.additionalProperties !== 'boolean') {
+                return false;
+            }
+            return canTrustPropertyCheck(propSchema, rootSchema, visiting);
+        });
+    }
+    finally {
+        visiting.delete(ref);
+    }
+};

package/dist/generators/generate-validation-expression.js

@@ -1,5 +1,6 @@
 import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
+import { multipleOfPassExpr } from '@amritk/helpers/multiple-of-check';
 import { resolveRef } from '@amritk/helpers/resolve-ref';
 import { safeAccessor } from '@amritk/helpers/safe-accessor';
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
@@ -33,16 +34,55 @@ export const scalarItemTypeCheck = (itemSchema, accessor) => {
         case 'string':
             return `typeof ${accessor} === "string"`;
         case 'number':
+            return `typeof ${accessor} === "number"`;
         case 'integer':
+            // `integer` items reject non-integral numbers; a bare typeof accepts `1.5`.
+            return `typeof ${accessor} === "number" && Number.isInteger(${accessor})`;
+        case 'boolean':
+            return `typeof ${accessor} === "boolean"`;
+        case 'null':
+            return `${accessor} === null`;
+        default:
+            return null;
+    }
+};
+/**
+ * A boolean type check for a single JSON Schema primitive type name. Unlike
+ * {@link scalarItemTypeCheck} this also covers `array`/`object` (as inline shape
+ * checks, so no `isObject` import is assumed) and enforces `integer` with
+ * `Number.isInteger` — a bare `typeof === "number"` accepts `1.5`. Used to build
+ * the disjunction for an array-form `type` (e.g. `["string","null"]`).
+ */
+const singleTypeCheck = (accessor, type) => {
+    switch (type) {
+        case 'string':
+            return `typeof ${accessor} === "string"`;
+        case 'number':
             return `typeof ${accessor} === "number"`;
+        case 'integer':
+            return `typeof ${accessor} === "number" && Number.isInteger(${accessor})`;
         case 'boolean':
             return `typeof ${accessor} === "boolean"`;
         case 'null':
             return `${accessor} === null`;
+        case 'array':
+            return `Array.isArray(${accessor})`;
+        case 'object':
+            return `typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`;
         default:
             return null;
     }
 };
+/**
+ * Returns the list of type names when `schema.type` is an array (the JSON Schema
+ * multi-type / nullable idiom, e.g. `["string","null"]`), or `null` for a single
+ * or absent type. Multi-type is validated as a *disjunction* of per-type checks.
+ */
+const getTypeArray = (schema) => {
+    if (!isSchemaObject(schema) || !('type' in schema) || !Array.isArray(schema.type))
+        return null;
+    return schema.type;
+};
 /**
  * Generates a type coercion expression for converting a value to the expected type.
  */
@@ -171,6 +211,20 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
             ? `${accessor} === ${constLiteral} ? ${accessor} : ${constLiteral}`
             : `${accessor} === ${constLiteral} ? ${accessor} : (${accessor} !== undefined ? ${constLiteral} : undefined)`;
     }
+    // Array-form `type` (multi-type / nullable, e.g. `["string","null"]`). `hasType`
+    // is false for an array `type`, so without this the value would fall through
+    // every branch below and emit NO validation — not even a required-presence
+    // check. Emit a disjunction: the value is accepted when it matches ANY listed
+    // type, otherwise it is coerced to the default (required) or dropped (optional).
+    // A missing value fails every disjunct, so `required` presence is still enforced.
+    const typeArray = getTypeArray(schema);
+    if (typeArray && !hasEnum(schema)) {
+        const checks = typeArray.map((t) => singleTypeCheck(accessor, t)).filter((c) => c !== null);
+        if (checks.length > 0) {
+            const combined = checks.map((c) => `(${c})`).join(' || ');
+            return isRequired ? `${combined} ? ${accessor} : ${defaultValue}` : `${combined} ? ${accessor} : undefined`;
+        }
+    }
     if (!hasType(schema) && !hasEnum(schema)) {
         return `${accessor} ?? ${defaultValue}`;
     }
@@ -207,6 +261,11 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
             case 'number':
             case 'integer': {
                 checks.push(`typeof ${accessor} === "number"`);
+                // `integer` must reject non-integral numbers; a bare `typeof === "number"`
+                // accepts `1.5`. Matches the validators package (which uses Number.isInteger).
+                if (schema.type === 'integer') {
+                    checks.push(`Number.isInteger(${accessor})`);
+                }
                 if (hasMinimum(schema)) {
                     checks.push(`${accessor} >= ${schema.minimum}`);
                 }
@@ -220,7 +279,7 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
                     checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
                 }
                 if (hasMultipleOf(schema)) {
-                    checks.push(`${accessor} % ${schema.multipleOf} === 0`);
+                    checks.push(multipleOfPassExpr(accessor, schema.multipleOf));
                 }
                 break;
             }
@@ -248,7 +307,7 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
                 // Check required properties exist
                 if (hasRequired(schema) && schema.required.length > 0) {
                     for (const requiredKey of schema.required) {
-                        checks.push(`"${requiredKey}" in ${accessor}`);
+                        checks.push(`${JSON.stringify(requiredKey)} in ${accessor}`);
                     }
                 }
                 // Check minProperties

package/dist/helpers/collect-helpers.js

@@ -11,7 +11,9 @@ const EMBEDDED_NAMED_EXPORTS = {
     'validate-record': 'validateRecord',
     'has-ref': 'hasRef',
 };
-const embeddedImport = (helper, prefix) => `import { ${EMBEDDED_NAMED_EXPORTS[helper]} } from '${prefix}_helpers/${helper}';`;
+const embeddedImport = (helper, prefix) => 
+// `.js` extension so the embedded-helper import resolves under Node ESM, not only Bun.
+`import { ${EMBEDDED_NAMED_EXPORTS[helper]} } from '${prefix}_helpers/${helper}.js';`;
 /**
  * Detects which runtime helpers a generated parser body references.
  *

package/dist/helpers/collect-imports.js

@@ -2,7 +2,11 @@ import { refToFilename } from '@amritk/helpers/ref-to-filename';
 import { refToName } from '@amritk/helpers/ref-to-name';
 import { resolveRef } from '@amritk/helpers/resolve-ref';
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef } from '@amritk/helpers/schema-guards';
-const getImportPathForFilename = (filename) => `./${filename}`;
+// Emit an explicit `.js` extension on the relative specifier. Node's ESM resolver
+// requires it (extensionless relative imports only work under a bundler or Bun),
+// and `./x.js` pointing at a sibling `x.ts` is the standard TS NodeNext form —
+// accepted by Bun, esbuild, webpack, and tsc alike.
+const getImportPathForFilename = (filename) => `./${filename}.js`;
 /**
  * Collects all import statements needed for a schema by finding $ref references
  * that are directly used in the type definition (from properties, items, etc.).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -48,8 +48,8 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.10.1",
-    "@amritk/generate-markdown": "0.4.0"
+    "@amritk/helpers": "0.10.3",
+    "@amritk/generate-markdown": "0.4.1"
   },
   "devDependencies": {
     "@sinclair/typebox": "^0.34.49",