orizu 0.5.26 → 0.5.28

package/dist/instruction-set-lock/index.js

@@ -0,0 +1,459 @@
+import { instructionSetLockSchemaV1 } from './schema.v1.js';
+export class LockParseError extends Error {
+    code;
+    path;
+    constructor(code, path) {
+        super(code);
+        this.name = 'LockParseError';
+        this.code = code;
+        this.path = path;
+    }
+}
+export class SpecifierParseError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.name = 'SpecifierParseError';
+        this.code = code;
+    }
+}
+const lockSchema = instructionSetLockSchemaV1;
+const rootSchema = lockSchema;
+export const INSTRUCTION_SET_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+export const INSTRUCTION_SET_PROFILE_SLUG = /^[a-z0-9][a-z0-9._-]*__[a-z0-9][a-z0-9._-]*$/u;
+export const INSTRUCTION_SET_COMPONENT_KEY = /^(?!\.)[A-Za-z0-9._-]+$/u;
+const WINDOWS_RESERVED_COMPONENT_KEY = /^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/iu;
+export const INSTRUCTION_SET_HELPER_PATH = /^helpers\/(?!\.{1,2}(?:\/|$))(?!.*\/\.{1,2}(?:\/|$))[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/u;
+export const MAX_VERSION_NUMBER = 2_147_483_647;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+export function windowsPathIdentity(value) {
+    return value.toLowerCase().replace(/[. ]+$/u, '');
+}
+function escapeJsonPointer(segment) {
+    return segment.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function childPath(path, segment) {
+    return `${path}/${escapeJsonPointer(segment)}`;
+}
+function schemaAtReference(reference) {
+    if (!reference.startsWith('#/'))
+        return {};
+    let current = lockSchema;
+    for (const encodedSegment of reference.slice(2).split('/')) {
+        const segment = encodedSegment.replaceAll('~1', '/').replaceAll('~0', '~');
+        if (!current || typeof current !== 'object' || Array.isArray(current))
+            return {};
+        current = current[segment];
+    }
+    return current && typeof current === 'object' && !Array.isArray(current)
+        ? current
+        : {};
+}
+function hasJsonType(value, expected) {
+    if (expected === 'null')
+        return value === null;
+    if (expected === 'array')
+        return Array.isArray(value);
+    if (expected === 'object')
+        return value !== null && typeof value === 'object' && !Array.isArray(value);
+    if (expected === 'integer')
+        return typeof value === 'number' && Number.isSafeInteger(value);
+    return typeof value === expected;
+}
+function isValidDateTime(value) {
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.valueOf()))
+        return false;
+    const canonicalUtc = /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}Z$/u;
+    return !canonicalUtc.test(value) || parsed.toISOString() === value;
+}
+function firstSchemaViolation(value, schema, path) {
+    if (schema.$ref)
+        return firstSchemaViolation(value, schemaAtReference(schema.$ref), path);
+    if (Object.hasOwn(schema, 'const') && value !== schema.const)
+        return path || '/';
+    if (schema.type) {
+        const expectedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (!expectedTypes.some(expected => hasJsonType(value, expected)))
+            return path || '/';
+    }
+    if (typeof value === 'string') {
+        if (schema.minLength !== undefined && value.length < schema.minLength)
+            return path || '/';
+        if (schema.pattern && !new RegExp(schema.pattern, 'u').test(value))
+            return path || '/';
+        if (schema.format === 'uuid' && !UUID.test(value))
+            return path || '/';
+        if (schema.format === 'date-time' && !isValidDateTime(value))
+            return path || '/';
+    }
+    if (typeof value === 'number') {
+        if (schema.minimum !== undefined && value < schema.minimum)
+            return path || '/';
+        if (schema.maximum !== undefined && value > schema.maximum)
+            return path || '/';
+    }
+    if (Array.isArray(value)) {
+        if (schema.uniqueItems) {
+            const seen = new Set(value.map(item => JSON.stringify(item)));
+            if (seen.size !== value.length)
+                return path || '/';
+        }
+        if (schema.items) {
+            for (let index = 0; index < value.length; index += 1) {
+                const violation = firstSchemaViolation(value[index], schema.items, childPath(path, String(index)));
+                if (violation)
+                    return violation;
+            }
+        }
+        return null;
+    }
+    if (value === null || typeof value !== 'object')
+        return null;
+    const object = value;
+    const keys = Object.keys(object);
+    if (schema.minProperties !== undefined && keys.length < schema.minProperties)
+        return path || '/';
+    for (const required of schema.required ?? []) {
+        if (!Object.hasOwn(object, required))
+            return childPath(path, required);
+    }
+    for (const key of keys) {
+        const keyPath = childPath(path, key);
+        if (schema.propertyNames) {
+            const violation = firstSchemaViolation(key, schema.propertyNames, keyPath);
+            if (violation)
+                return violation;
+        }
+        const propertySchema = schema.properties && Object.hasOwn(schema.properties, key)
+            ? schema.properties[key]
+            : undefined;
+        if (propertySchema) {
+            const violation = firstSchemaViolation(object[key], propertySchema, keyPath);
+            if (violation)
+                return violation;
+            continue;
+        }
+        const matchingSchemas = Object.entries(schema.patternProperties ?? {})
+            .filter(([pattern]) => new RegExp(pattern, 'u').test(key))
+            .map(([, matchingSchema]) => matchingSchema);
+        if (matchingSchemas.length > 0) {
+            for (const matchingSchema of matchingSchemas) {
+                const violation = firstSchemaViolation(object[key], matchingSchema, keyPath);
+                if (violation)
+                    return violation;
+            }
+            continue;
+        }
+        if (schema.additionalProperties === false)
+            return keyPath;
+        if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+            const violation = firstSchemaViolation(object[key], schema.additionalProperties, keyPath);
+            if (violation)
+                return violation;
+        }
+    }
+    return null;
+}
+function objectRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function isUnsafeComponentKey(key) {
+    return !INSTRUCTION_SET_COMPONENT_KEY.test(key);
+}
+export function validateInstructionSetComponentKeys(componentKeys, pathPrefix = '/components', rejectWindowsReserved = false) {
+    const componentKeysByCaseFold = new Map();
+    for (const componentKey of componentKeys) {
+        const caseFoldedKey = componentKey.toLowerCase();
+        const collidingKey = componentKeysByCaseFold.get(caseFoldedKey);
+        if (collidingKey !== undefined) {
+            throw new LockParseError(`instruction_set_lock_component_key_collision:${collidingKey},${componentKey}`);
+        }
+        componentKeysByCaseFold.set(caseFoldedKey, componentKey);
+        const path = childPath(pathPrefix, componentKey);
+        if (rejectWindowsReserved && WINDOWS_RESERVED_COMPONENT_KEY.test(componentKey)) {
+            throw new LockParseError(`lock_component_key_reserved:${path}`, path);
+        }
+        if (isUnsafeComponentKey(componentKey)) {
+            throw new LockParseError(`lock_component_key_unsafe:${path}`, path);
+        }
+    }
+}
+function validateComponentKeys(value) {
+    const instructionSets = objectRecord(objectRecord(value)?.instructionSets);
+    if (!instructionSets)
+        return;
+    for (const [setSlug, instructionSetValue] of Object.entries(instructionSets)) {
+        const profiles = objectRecord(objectRecord(instructionSetValue)?.profiles);
+        if (!profiles)
+            continue;
+        for (const [profileSlug, profileValue] of Object.entries(profiles)) {
+            const versions = objectRecord(objectRecord(profileValue)?.versions);
+            if (!versions)
+                continue;
+            for (const [versionKey, versionValue] of Object.entries(versions)) {
+                const components = objectRecord(objectRecord(versionValue)?.components);
+                if (!components)
+                    continue;
+                const pathPrefix = [
+                    'instructionSets',
+                    setSlug,
+                    'profiles',
+                    profileSlug,
+                    'versions',
+                    versionKey,
+                    'components',
+                ].reduce(childPath, '');
+                validateInstructionSetComponentKeys(Object.keys(components), pathPrefix);
+            }
+        }
+    }
+}
+function validateLockSlugs(value) {
+    const instructionSets = objectRecord(objectRecord(value)?.instructionSets);
+    if (!instructionSets)
+        return;
+    for (const [setSlug, instructionSetValue] of Object.entries(instructionSets)) {
+        if (!INSTRUCTION_SET_SLUG.test(setSlug)) {
+            const path = childPath(childPath('', 'instructionSets'), setSlug);
+            throw new LockParseError(`lock_set_slug_invalid:${path}`, path);
+        }
+        const instructionSet = objectRecord(instructionSetValue);
+        const defaultSlug = instructionSet?.default;
+        if (typeof defaultSlug === 'string' && !INSTRUCTION_SET_PROFILE_SLUG.test(defaultSlug)) {
+            const path = [
+                'instructionSets',
+                setSlug,
+                'default',
+            ].reduce(childPath, '');
+            throw new LockParseError(`lock_default_slug_invalid:${path}`, path);
+        }
+        const profiles = objectRecord(instructionSet?.profiles);
+        if (!profiles)
+            continue;
+        for (const profileSlug of Object.keys(profiles)) {
+            if (INSTRUCTION_SET_PROFILE_SLUG.test(profileSlug))
+                continue;
+            const path = [
+                'instructionSets',
+                setSlug,
+                'profiles',
+                profileSlug,
+            ].reduce(childPath, '');
+            throw new LockParseError(`lock_profile_slug_invalid:${path}`, path);
+        }
+    }
+}
+function validateHelperPaths(value) {
+    const helpers = objectRecord(objectRecord(value)?.helpers);
+    if (!helpers)
+        return;
+    const helperPathsByWindowsIdentity = new Map();
+    for (const helperPath of Object.keys(helpers)) {
+        const pathIdentity = windowsPathIdentity(helperPath);
+        const collidingPath = helperPathsByWindowsIdentity.get(pathIdentity);
+        if (collidingPath !== undefined) {
+            throw new LockParseError(`instruction_set_lock_helper_path_collision:${collidingPath},${helperPath}`);
+        }
+        helperPathsByWindowsIdentity.set(pathIdentity, helperPath);
+        if (INSTRUCTION_SET_HELPER_PATH.test(helperPath))
+            continue;
+        const path = childPath(childPath('', 'helpers'), helperPath);
+        throw new LockParseError(`lock_helper_path_invalid:${path}`, path);
+    }
+}
+function validatePinSpecifiers(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return;
+    const pins = value.pins;
+    if (!Array.isArray(pins))
+        return;
+    for (const [index, pin] of pins.entries()) {
+        if (typeof pin !== 'string')
+            continue;
+        const path = childPath(childPath('', 'pins'), String(index));
+        try {
+            const specifier = parseSpecifier(pin);
+            if (specifier.versionNumber === undefined) {
+                throw new SpecifierParseError('specifier_invalid_version');
+            }
+        }
+        catch (error) {
+            if (!(error instanceof SpecifierParseError))
+                throw error;
+            throw new LockParseError(`lock_pin_invalid:${path}:${error.code}`, path);
+        }
+    }
+}
+function validateUniqueIds(lock) {
+    const instructionSetIds = new Set();
+    const profileVersionIds = new Set();
+    for (const [setSlug, instructionSet] of Object.entries(lock.instructionSets)) {
+        const instructionSetId = instructionSet.instructionSetId.toLowerCase();
+        if (instructionSetIds.has(instructionSetId)) {
+            const path = [
+                'instructionSets',
+                setSlug,
+                'instructionSetId',
+            ].reduce(childPath, '');
+            throw new LockParseError(`lock_instruction_set_id_duplicate:${path}`, path);
+        }
+        instructionSetIds.add(instructionSetId);
+        for (const [profileSlug, profile] of Object.entries(instructionSet.profiles)) {
+            for (const [versionKey, version] of Object.entries(profile.versions)) {
+                const profileVersionId = version.profileVersionId.toLowerCase();
+                if (profileVersionIds.has(profileVersionId)) {
+                    const path = [
+                        'instructionSets',
+                        setSlug,
+                        'profiles',
+                        profileSlug,
+                        'versions',
+                        versionKey,
+                        'profileVersionId',
+                    ].reduce(childPath, '');
+                    throw new LockParseError(`lock_profile_version_id_duplicate:${path}`, path);
+                }
+                profileVersionIds.add(profileVersionId);
+            }
+        }
+    }
+}
+function validateLockValue(value) {
+    if (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        typeof value.lockfileVersion === 'number' &&
+        value.lockfileVersion !== 1) {
+        throw new LockParseError('lock_unsupported_version');
+    }
+    validateComponentKeys(value);
+    validateLockSlugs(value);
+    validateHelperPaths(value);
+    validatePinSpecifiers(value);
+    const violation = firstSchemaViolation(value, rootSchema, '');
+    if (violation) {
+        throw new LockParseError(`lock_schema_violation:${violation}`, violation);
+    }
+    const lock = value;
+    validateUniqueIds(lock);
+    for (const [setSlug, instructionSet] of Object.entries(lock.instructionSets)) {
+        for (const [profileSlug, profile] of Object.entries(instructionSet.profiles)) {
+            for (const [versionKey, version] of Object.entries(profile.versions)) {
+                if (versionKey !== `v${version.versionNumber}`) {
+                    const path = childPath(childPath(childPath(childPath(childPath('', 'instructionSets'), setSlug), 'profiles'), profileSlug), 'versions');
+                    const versionPath = childPath(path, versionKey);
+                    throw new LockParseError(`lock_schema_violation:${versionPath}`, versionPath);
+                }
+            }
+            if (profile.production !== null && !Object.hasOwn(profile.versions, profile.production)) {
+                throw new LockParseError('lock_production_not_a_version', childPath(childPath(childPath(childPath('', 'instructionSets'), setSlug), 'profiles'), profileSlug));
+            }
+        }
+    }
+    return lock;
+}
+export function parseLock(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw new LockParseError('lock_invalid_json');
+    }
+    return validateLockValue(value);
+}
+function orderedObject(entries) {
+    return new Map(entries);
+}
+function orderedRecord(record, mapValue) {
+    return orderedObject(Object.keys(record).sort().map(key => [key, mapValue(record[key])]));
+}
+function stringifyOrdered(value, depth = 0) {
+    if (value instanceof Map) {
+        if (value.size === 0)
+            return '{}';
+        const entries = [...value.entries()].map(([key, child]) => `${'  '.repeat(depth + 1)}${JSON.stringify(key)}: ${stringifyOrdered(child, depth + 1)}`);
+        return `{\n${entries.join(',\n')}\n${'  '.repeat(depth)}}`;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const items = value.map(item => `${'  '.repeat(depth + 1)}${stringifyOrdered(item, depth + 1)}`);
+        return `[\n${items.join(',\n')}\n${'  '.repeat(depth)}]`;
+    }
+    return JSON.stringify(value);
+}
+export function serializeLock(lock) {
+    const validLock = validateLockValue(lock);
+    const instructionSets = orderedRecord(validLock.instructionSets, instructionSet => orderedObject([
+        ['instructionSetId', instructionSet.instructionSetId],
+        ['default', instructionSet.default],
+        ['profiles', orderedRecord(instructionSet.profiles, profile => orderedObject([
+                ...(profile.modelConfigIdentity === undefined ? [] : [['modelConfigIdentity', profile.modelConfigIdentity]]),
+                ['production', profile.production],
+                ['versions', orderedObject(Object.entries(profile.versions)
+                        .sort((left, right) => left[1].versionNumber - right[1].versionNumber)
+                        .map(([versionKey, version]) => [versionKey, orderedObject([
+                            ['profileVersionId', version.profileVersionId],
+                            ['versionNumber', version.versionNumber],
+                            ['digest', version.digest],
+                            ['components', orderedRecord(version.components, digest => digest)],
+                            ['syncedAt', version.syncedAt],
+                        ])]))],
+            ]))],
+    ]));
+    const entries = [
+        ['lockfileVersion', 1],
+        ['project', validLock.project],
+        ['instructionSets', instructionSets],
+    ];
+    if (validLock.helpers)
+        entries.push([
+            'helpers',
+            orderedRecord(validLock.helpers, digest => digest),
+        ]);
+    if (validLock.pins)
+        entries.push(['pins', [...validLock.pins]]);
+    return `${stringifyOrdered(orderedObject(entries))}\n`;
+}
+export function parseSpecifier(text) {
+    if (text.length === 0)
+        throw new SpecifierParseError('specifier_empty');
+    const firstSlash = text.indexOf('/');
+    if (firstSlash === -1) {
+        if (text.includes('@'))
+            throw new SpecifierParseError('specifier_version_without_profile');
+        if (!INSTRUCTION_SET_SLUG.test(text))
+            throw new SpecifierParseError('specifier_invalid_set');
+        return { set: text };
+    }
+    const set = text.slice(0, firstSlash);
+    if (!INSTRUCTION_SET_SLUG.test(set))
+        throw new SpecifierParseError('specifier_invalid_set');
+    const profileAndVersion = text.slice(firstSlash + 1);
+    if (profileAndVersion.length === 0 || profileAndVersion.startsWith('@')) {
+        throw new SpecifierParseError('specifier_profile_missing');
+    }
+    const versionSuffix = /@v([0-9]+)$/u.exec(profileAndVersion);
+    if (versionSuffix && !/^[1-9][0-9]*$/u.test(versionSuffix[1])) {
+        throw new SpecifierParseError('specifier_invalid_version');
+    }
+    const profile = versionSuffix
+        ? profileAndVersion.slice(0, versionSuffix.index)
+        : profileAndVersion;
+    if (profile.length === 0)
+        throw new SpecifierParseError('specifier_profile_missing');
+    if (/\s/u.test(profile))
+        throw new SpecifierParseError('specifier_invalid_profile');
+    if (!versionSuffix)
+        return { set, profile };
+    const versionNumber = Number(versionSuffix[1]);
+    if (versionNumber < 1)
+        throw new SpecifierParseError('specifier_invalid_version');
+    if (versionNumber > MAX_VERSION_NUMBER)
+        throw new SpecifierParseError('specifier_invalid_version');
+    return { set, profile, versionNumber };
+}

package/dist/instruction-set-lock/schema.v1.d.ts

@@ -0,0 +1,136 @@
+export declare const instructionSetLockSchemaV1: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://orizu.ai/schemas/instruction-set-lock/v1";
+    readonly title: "Orizu instruction set Lock v1";
+    readonly type: "object";
+    readonly required: readonly ["lockfileVersion", "project", "instructionSets"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly lockfileVersion: {
+            readonly const: 1;
+        };
+        readonly project: {
+            readonly type: "string";
+            readonly pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*/[a-z0-9]+(?:-[a-z0-9]+)*$";
+        };
+        readonly instructionSets: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly patternProperties: {
+                readonly "^[a-z0-9]+(?:-[a-z0-9]+)*$": {
+                    readonly $ref: "#/$defs/instructionSet";
+                };
+            };
+        };
+        readonly helpers: {
+            readonly type: "object";
+            readonly propertyNames: {
+                readonly pattern: "^helpers\\/(?!\\.{1,2}(?:\\/|$))(?!.*\\/\\.{1,2}(?:\\/|$))[A-Za-z0-9._-]+(?:\\/[A-Za-z0-9._-]+)*$";
+            };
+            readonly additionalProperties: {
+                readonly $ref: "#/$defs/sha256";
+            };
+        };
+        readonly pins: {
+            readonly type: "array";
+            readonly uniqueItems: true;
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*/[^\\s]+@v[1-9][0-9]*$";
+            };
+        };
+    };
+    readonly $defs: {
+        readonly sha256: {
+            readonly type: "string";
+            readonly pattern: "^sha256:[0-9a-f]{64}$";
+        };
+        readonly instructionSet: {
+            readonly type: "object";
+            readonly required: readonly ["instructionSetId", "default", "profiles"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly instructionSetId: {
+                    readonly type: "string";
+                    readonly format: "uuid";
+                    readonly pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89aAbB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$";
+                };
+                readonly default: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-z0-9][a-z0-9._-]*__[a-z0-9][a-z0-9._-]*$";
+                };
+                readonly profiles: {
+                    readonly type: "object";
+                    readonly minProperties: 1;
+                    readonly additionalProperties: false;
+                    readonly patternProperties: {
+                        readonly "^[a-z0-9][a-z0-9._-]*__[a-z0-9][a-z0-9._-]*$": {
+                            readonly $ref: "#/$defs/profile";
+                        };
+                    };
+                };
+            };
+        };
+        readonly profile: {
+            readonly type: "object";
+            readonly required: readonly ["production", "versions"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly modelConfigIdentity: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly production: {
+                    readonly type: readonly ["string", "null"];
+                    readonly pattern: "^v[1-9][0-9]*$";
+                };
+                readonly versions: {
+                    readonly type: "object";
+                    readonly minProperties: 1;
+                    readonly additionalProperties: false;
+                    readonly patternProperties: {
+                        readonly "^v[1-9][0-9]*$": {
+                            readonly $ref: "#/$defs/version";
+                        };
+                    };
+                };
+            };
+        };
+        readonly version: {
+            readonly type: "object";
+            readonly required: readonly ["profileVersionId", "versionNumber", "digest", "components", "syncedAt"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly profileVersionId: {
+                    readonly type: "string";
+                    readonly format: "uuid";
+                    readonly pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89aAbB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$";
+                };
+                readonly versionNumber: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly maximum: 2147483647;
+                };
+                readonly digest: {
+                    readonly $ref: "#/$defs/sha256";
+                };
+                readonly components: {
+                    readonly type: "object";
+                    readonly minProperties: 1;
+                    readonly propertyNames: {
+                        readonly pattern: "^(?!\\.)[A-Za-z0-9._-]+$";
+                    };
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/sha256";
+                    };
+                };
+                readonly syncedAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly pattern: "^(?:(?:[0-9]{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12][0-9]|3[01])|(?:0[469]|11)-(?:0[1-9]|[12][0-9]|30)|02-(?:0[1-9]|1[0-9]|2[0-8])))|(?:(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:00|0[48]|[2468][048]|[13579][26])00)-02-29))T(?:[01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]\\.[0-9]{3}Z$";
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=schema.v1.d.ts.map

package/dist/instruction-set-lock/schema.v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.v1.d.ts","sourceRoot":"","sources":["../../src/instruction-set-lock/schema.v1.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0J7B,CAAA"}