pi-proactive 0.2.0-beta.2 → 0.2.0-beta.3

package/node_modules/typebox/build/schema/intern/intern.mjs

@@ -1,9 +1,13 @@
-import { Arguments } from '../../system/arguments/index.mjs';
 import { Hashing, Memory } from '../../system/index.mjs';
-import * as Schema from '../types/index.mjs';
-import * as Stack from '../engine/_stack.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { Resolve } from '../resolve/index.mjs';
+import * as S from '../types/index.mjs';
+// ----------------------------------------------------------------
+// UnsupportedKeyword
+// ----------------------------------------------------------------
+function UnsupportedKeyword(keyword) {
+    throw Error(`UnsupportedKeyword '${keyword}'`);
+}
 // ----------------------------------------------------------------
 // UnresolvableRef
 // ----------------------------------------------------------------
@@ -68,7 +72,7 @@ function FromIf(context, schema) {
 // Items
 // ----------------------------------------------------------------
 function FromItems(context, schema) {
-    return Schema.IsItemsSized(schema) ? FromItemsSized(context, schema) : FromItemsUnsized(context, schema);
+    return S.IsItemsSized(schema) ? FromItemsSized(context, schema) : FromItemsUnsized(context, schema);
 }
 // ----------------------------------------------------------------
 // ItemsSized
@@ -121,59 +125,21 @@ function FromPropertyNames(context, schema) {
 // ----------------------------------------------------------------
 // Ref
 // ----------------------------------------------------------------
-function ResolveRef(stack, ref) {
-    const result = Resolve.Ref(stack, { $ref: ref });
-    return { schema: result.schema ?? UnresolvableRef(ref), stack: result.stack };
-}
-// ----------------------------------------------------------------
-// DynamicRef
-// ----------------------------------------------------------------
-function ResolveDynamicRef(stack, schema) {
-    return Resolve.DynamicRef(stack, schema) ?? UnresolvableRef(schema.$dynamicRef);
+function ResolveRef(context, schema, ref) {
+    return Resolve.Ref(context, schema, Resolve.DefaultBase, ref) ?? UnresolvableRef(ref);
 }
-// ----------------------------------------------------------------
-// RecursiveRef
-// ----------------------------------------------------------------
-function ResolveRecursiveRef(stack, schema) {
-    return Resolve.RecursiveRef(stack, schema) ?? UnresolvableRef(schema.$recursiveRef);
-}
-// ----------------------------------------------------------------
-// FromResolvedRef (shared logic for Ref, DynamicRef, RecursiveRef)
-// ----------------------------------------------------------------
-function FromResolvedRef(context, target, nextStack) {
-    const nextContext = { ...context, stack: nextStack };
+function FromRef(context, schema) {
+    // Resolve target
+    const target = ResolveRef(context.context, context.schema, schema.$ref);
+    // Check if target is resolving, if not, resolve
     const resolving = context.resolving.get(target);
     if (Guard.IsUndefined(resolving))
-        return FromSchema(nextContext, target);
+        return FromSchema(context, target);
     // Target is mid-intern, so this is a cycle (point at its reserved placeholder)
     resolving.used = true;
     return { $ref: `#/$defs/${resolving.key}` };
 }
 // ----------------------------------------------------------------
-// FromRef
-// ----------------------------------------------------------------
-function FromRef(context, schema) {
-    // Resolve target off the current traversal stack, carrying forward any resource crossing
-    const { schema: target, stack } = ResolveRef(context.stack, schema.$ref);
-    return FromResolvedRef(context, target, stack);
-}
-// ----------------------------------------------------------------
-// FromDynamicRef
-// ----------------------------------------------------------------
-function FromDynamicRef(context, schema) {
-    // Resolve target off the current traversal stack (dynamic scope depends on anchors seen so far)
-    const target = ResolveDynamicRef(context.stack, schema);
-    return FromResolvedRef(context, target, { ...context.stack, pendingResource: true });
-}
-// ----------------------------------------------------------------
-// FromRecursiveRef
-// ----------------------------------------------------------------
-function FromRecursiveRef(context, schema) {
-    // Resolve target off the current traversal stack (recursive scope depends on the path taken so far)
-    const target = ResolveRecursiveRef(context.stack, schema);
-    return FromResolvedRef(context, target, { ...context.stack, pendingResource: true });
-}
-// ----------------------------------------------------------------
 // Then
 // ----------------------------------------------------------------
 function FromThen(context, schema) {
@@ -195,45 +161,46 @@ function FromUnevaluatedProperties(context, schema) {
 // SchemaObject
 // ----------------------------------------------------------------
 function FromSchemaObject(context, schema) {
-    // Reference-style schemas resolve to another node and cannot contain other keywords
-    if (Schema.IsRef(schema))
+    // Reference schemas cannot contain other keywords
+    if (S.IsRef(schema))
         return FromRef(context, schema);
-    if (Schema.IsDynamicRef(schema))
-        return FromDynamicRef(context, schema);
-    if (Schema.IsRecursiveRef(schema))
-        return FromRecursiveRef(context, schema);
     // Check if the schema has already been resolved
     const existing = resolved.get(schema);
     if (!Guard.IsUndefined(existing))
         return existing;
+    // These keywords are unsupported
+    if (S.IsDynamicRef(schema))
+        UnsupportedKeyword('$dynamicRef');
+    if (S.IsRecursiveRef(schema))
+        UnsupportedKeyword('$recursiveRef');
     // Reserve a placeholder key in case a nested ref cycles back to this schema
     const reservation = { key: `x-ref-${context.resolving.size}`, used: false };
     context.resolving.set(schema, reservation);
     // Intern each subschema
     const remapped = {
-        ...(Schema.IsRefine(schema) ? { ['~refine']: schema['~refine'] } : {}),
-        ...(Schema.IsAdditionalItems(schema) ? { additionalItems: FromAdditionalItems(context, schema) } : {}),
-        ...(Schema.IsAdditionalProperties(schema) ? { additionalProperties: FromAdditionalProperties(context, schema) } : {}),
-        ...(Schema.IsAllOf(schema) ? { allOf: FromAllOf(context, schema) } : {}),
-        ...(Schema.IsAnyOf(schema) ? { anyOf: FromAnyOf(context, schema) } : {}),
-        ...(Schema.IsContains(schema) ? { contains: FromContains(context, schema) } : {}),
-        ...(Schema.IsDependentSchemas(schema) ? { dependentSchemas: FromDependentSchemas(context, schema) } : {}),
-        ...(Schema.IsElse(schema) ? { else: FromElse(context, schema) } : {}),
-        ...(Schema.IsIf(schema) ? { if: FromIf(context, schema) } : {}),
-        ...(Schema.IsItems(schema) ? { items: FromItems(context, schema) } : {}),
-        ...(Schema.IsNot(schema) ? { not: FromNot(context, schema) } : {}),
-        ...(Schema.IsOneOf(schema) ? { oneOf: FromOneOf(context, schema) } : {}),
-        ...(Schema.IsPatternProperties(schema) ? { patternProperties: FromPatternProperties(context, schema) } : {}),
-        ...(Schema.IsPrefixItems(schema) ? { prefixItems: FromPrefixItems(context, schema) } : {}),
-        ...(Schema.IsProperties(schema) ? { properties: FromProperties(context, schema) } : {}),
-        ...(Schema.IsPropertyNames(schema) ? { propertyNames: FromPropertyNames(context, schema) } : {}),
-        ...(Schema.IsThen(schema) ? { then: FromThen(context, schema) } : {}),
-        ...(Schema.IsUnevaluatedItems(schema) ? { unevaluatedItems: FromUnevaluatedItems(context, schema) } : {}),
-        ...(Schema.IsUnevaluatedProperties(schema) ? { unevaluatedProperties: FromUnevaluatedProperties(context, schema) } : {})
+        ...(S.IsRefine(schema) ? { ['~refine']: schema['~refine'] } : {}),
+        ...(S.IsAdditionalItems(schema) ? { additionalItems: FromAdditionalItems(context, schema) } : {}),
+        ...(S.IsAdditionalProperties(schema) ? { additionalProperties: FromAdditionalProperties(context, schema) } : {}),
+        ...(S.IsAllOf(schema) ? { allOf: FromAllOf(context, schema) } : {}),
+        ...(S.IsAnyOf(schema) ? { anyOf: FromAnyOf(context, schema) } : {}),
+        ...(S.IsContains(schema) ? { contains: FromContains(context, schema) } : {}),
+        ...(S.IsDependentSchemas(schema) ? { dependentSchemas: FromDependentSchemas(context, schema) } : {}),
+        ...(S.IsElse(schema) ? { else: FromElse(context, schema) } : {}),
+        ...(S.IsIf(schema) ? { if: FromIf(context, schema) } : {}),
+        ...(S.IsItems(schema) ? { items: FromItems(context, schema) } : {}),
+        ...(S.IsNot(schema) ? { not: FromNot(context, schema) } : {}),
+        ...(S.IsOneOf(schema) ? { oneOf: FromOneOf(context, schema) } : {}),
+        ...(S.IsPatternProperties(schema) ? { patternProperties: FromPatternProperties(context, schema) } : {}),
+        ...(S.IsPrefixItems(schema) ? { prefixItems: FromPrefixItems(context, schema) } : {}),
+        ...(S.IsProperties(schema) ? { properties: FromProperties(context, schema) } : {}),
+        ...(S.IsPropertyNames(schema) ? { propertyNames: FromPropertyNames(context, schema) } : {}),
+        ...(S.IsThen(schema) ? { then: FromThen(context, schema) } : {}),
+        ...(S.IsUnevaluatedItems(schema) ? { unevaluatedItems: FromUnevaluatedItems(context, schema) } : {}),
+        ...(S.IsUnevaluatedProperties(schema) ? { unevaluatedProperties: FromUnevaluatedProperties(context, schema) } : {})
     };
     context.resolving.delete(schema);
-    // Discard resolution keywords and finalize the interned schema
-    const interned = Memory.Discard(Memory.Assign(schema, remapped), ['$id', '$defs', '$anchor', '$dynamicAnchor', '$recursionAnchor']);
+    // Finalize and register the result
+    const interned = Memory.Discard(Memory.Assign(schema, remapped), ['$id']);
     const key = reservation.used ? reservation.key : HashKey(interned);
     registry.set(key, interned);
     // Result
@@ -257,8 +224,7 @@ function FromSchemaBoolean(_context, schema) {
 // Schema
 // ----------------------------------------------------------------
 function FromSchema(context, schema) {
-    const next = { ...context, stack: Stack.NextStack(context.stack, schema) };
-    return Schema.IsSchemaBoolean(schema) ? FromSchemaBoolean(next, schema) : FromSchemaObject(next, schema);
+    return S.IsSchemaBoolean(schema) ? FromSchemaBoolean(context, schema) : FromSchemaObject(context, schema);
 }
 // ----------------------------------------------------------------
 // BooleanEntry
@@ -272,22 +238,22 @@ function BooleanEntry(schema) {
 // ----------------------------------------------------------------
 const registry = new Map();
 const resolved = new Map();
-/** (Experimental) This function restructures the schema such that each distinct sub-schema is stored exactly once in a $defs object and keyed by content hash. */
-export function Intern(...args) {
-    const [context, schema] = Arguments.Match(args, {
-        2: (context, schema) => [context, schema],
-        1: (schema) => [{}, schema]
-    });
+/**
+ * [Experimental] Performs a Common Subexpression Elimination (CSE) transform on the given
+ * schema. This function restructures the schema such that each distinct sub-schema is stored
+ * exactly once in a $defs object and keyed by content hash. This function can be used to
+ * both compress and optimize schemas prior to compilation.
+ */
+export function Intern(schema) {
     registry.clear();
     resolved.clear();
-    if (Schema.IsSchemaBoolean(schema))
+    if (S.IsSchemaBoolean(schema))
         return BooleanEntry(schema);
-    const defs = Schema.IsDefs(schema) ? schema.$defs : {};
-    const rootStack = Stack.Stack({ ...context, ...defs }, schema);
-    const { schema: entry, stack } = Schema.IsRef(schema) ? ResolveRef(Stack.NextStack(rootStack, schema), schema.$ref) : { schema, stack: rootStack };
-    if (Schema.IsSchemaBoolean(entry))
+    const context = S.IsDefs(schema) ? schema.$defs : {};
+    const entry = S.IsRef(schema) ? ResolveRef(context, schema, schema.$ref) : schema;
+    if (S.IsSchemaBoolean(entry))
         return BooleanEntry(entry);
-    const ref_context = { stack, resolving: new Map() };
+    const ref_context = { schema, context, resolving: new Map() };
     const result = FromSchema(ref_context, entry);
     return { $ref: result.$ref, $defs: Object.fromEntries(registry) };
 }

package/node_modules/typebox/build/schema/parse.mjs

@@ -1,6 +1,5 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
-import { EnableParseErrors, DisableParseErrors } from '../system/settings/internal.mjs';
 import { Arguments } from '../system/arguments/index.mjs';
 import { Check } from './check.mjs';
 import { Errors } from './errors.mjs';
@@ -18,9 +17,7 @@ export class ParseError {
 // ThrowParseError
 // ------------------------------------------------------------------
 export function ThrowParseError(context, schema, value) {
-    EnableParseErrors();
     const result = Errors(context, schema, value);
-    DisableParseErrors();
     throw new ParseError(schema, value, result[1]);
 }
 /** Parses a value against the provided schema */

package/node_modules/typebox/build/schema/pointer/pointer.d.mts

@@ -1,5 +1,10 @@
+/** Returns an array of path indices for the given pointer */
 export declare function Indices(pointer: string): string[];
-export declare function Has(value: unknown, pointer: string): boolean;
+/** Returns true if a value exists at the current pointer */
+export declare function Has(value: unknown, pointer: string): unknown;
+/** Gets a value at the pointer, or undefined if not exists */
 export declare function Get(value: unknown, pointer: string): unknown;
+/** Sets a value at the given pointer. May throw if the target value is not indexable */
 export declare function Set(value: unknown, pointer: string, next: unknown): unknown;
+/** Deletes the value at the given pointer. May throw if the target value is not indexable */
 export declare function Delete(value: unknown, pointer: string): unknown;

package/node_modules/typebox/build/schema/pointer/pointer.mjs

@@ -1,89 +1,106 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Throw
+// Asserts
 // ------------------------------------------------------------------
-function Throw(message) {
-    throw Error(message);
+function AssertNotRoot(indices) {
+    if (indices.length === 0)
+        throw Error('Cannot set root');
 }
-function ThrowUnsafePropertyKey() {
-    Throw('Pointer contains unsafe property key');
+function AssertCanSet(value) {
+    if (!Guard.IsObject(value))
+        throw Error('Cannot set value');
 }
-function ThrowCannotSetRoot() {
-    Throw('Cannot set value');
+function AssertIndex(index) {
+    if (Guard.IsUnsafePropertyKey(index))
+        throw Error('Pointer contains unsafe property key');
+}
+function AssertIndices(indices) {
+    for (const index of indices)
+        AssertIndex(index);
+}
+// ------------------------------------------------------------------
+// Indices
+// ------------------------------------------------------------------
+function IsNumericIndex(index) {
+    return /^(0|[1-9]\d*)$/.test(index);
+}
+function TakeIndexRight(indices) {
+    return [
+        indices.slice(0, indices.length - 1),
+        indices.slice(indices.length - 1)[0]
+    ];
+}
+function HasIndex(index, value) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
+}
+function GetIndex(index, value) {
+    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
+}
+function GetIndices(indices, value) {
+    return indices.reduce((value, index) => GetIndex(index, value), value);
 }
 // ------------------------------------------------------------------
 // Indices
 // ------------------------------------------------------------------
+/** Returns an array of path indices for the given pointer */
 export function Indices(pointer) {
-    const indices = pointer.split('/').map(index => index.replace(/~1/g, '/').replace(/~0/g, '~'));
-    return indices[0] === '' ? indices.slice(1) : indices;
+    if (Guard.IsEqual(pointer.length, 0))
+        return [];
+    const indices = pointer.split("/").map(index => index.replace(/~1/g, "/").replace(/~0/g, "~"));
+    return (indices.length > 0 && indices[0] === '') ? indices.slice(1) : indices;
 }
 // ------------------------------------------------------------------
 // Has
 // ------------------------------------------------------------------
+/** Returns true if a value exists at the current pointer */
 export function Has(value, pointer) {
     let current = value;
-    for (const index of Indices(pointer)) {
-        if (!Guard.IsObject(current) || !Guard.HasPropertyKey(current, index))
+    return Indices(pointer).every(index => {
+        if (!HasIndex(index, current))
             return false;
         current = current[index];
-    }
-    return true;
+        return true;
+    });
 }
 // ------------------------------------------------------------------
 // Get
 // ------------------------------------------------------------------
+/** Gets a value at the pointer, or undefined if not exists */
 export function Get(value, pointer) {
-    let current = value;
-    for (const index of Indices(pointer)) {
-        if (!Guard.IsObject(current) || Guard.IsUnsafePropertyKey(index))
-            return undefined;
-        current = current[index];
-    }
-    return current;
-}
-// ------------------------------------------------------------------
-// Get
-// ------------------------------------------------------------------
-function Parent(value, indices, last) {
-    let current = value;
-    for (const index of indices) {
-        if (Guard.IsUnsafePropertyKey(index))
-            ThrowUnsafePropertyKey();
-        current = Guard.IsObject(current) ? current[index] : undefined;
-    }
-    if (Guard.IsUnsafePropertyKey(last))
-        ThrowUnsafePropertyKey();
-    if (!Guard.IsObject(current))
-        ThrowCannotSetRoot();
-    return current;
+    const indices = Indices(pointer);
+    return GetIndices(indices, value);
 }
 // ------------------------------------------------------------------
 // Set
 // ------------------------------------------------------------------
+/** Sets a value at the given pointer. May throw if the target value is not indexable */
 export function Set(value, pointer, next) {
     const indices = Indices(pointer);
-    const last = indices.pop();
-    if (Guard.IsUndefined(last))
-        ThrowCannotSetRoot();
-    Parent(value, indices, last)[last] = next;
+    AssertNotRoot(indices);
+    AssertIndices(indices);
+    const [head, index] = TakeIndexRight(indices);
+    const parent = GetIndices(head, value);
+    AssertCanSet(parent);
+    parent[index] = next;
     return value;
 }
 // ------------------------------------------------------------------
 // Delete
 // ------------------------------------------------------------------
+/** Deletes the value at the given pointer. May throw if the target value is not indexable */
 export function Delete(value, pointer) {
     const indices = Indices(pointer);
-    const last = indices.pop();
-    if (Guard.IsUndefined(last))
-        ThrowCannotSetRoot();
-    const parent = Parent(value, indices, last);
-    if (Guard.IsArray(parent) && /^(0|[1-9]\d*)$/.test(last)) {
-        parent.splice(Number(last), 1);
+    AssertNotRoot(indices);
+    AssertIndices(indices);
+    const [head, index] = TakeIndexRight(indices);
+    const parent = GetIndices(head, value);
+    AssertCanSet(parent);
+    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
+        parent.splice(+index, 1);
     }
     else {
-        delete parent[last];
+        delete parent[index];
     }
     return value;
 }

package/node_modules/typebox/build/schema/resolve/resolve.d.mts

@@ -1,9 +1,35 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from '../engine/_stack.mjs';
-export interface XRefResult {
+export declare const DefaultBase = "https://json-schema.org";
+export interface StackFrame {
+    context: Record<string, Schema.XSchema>;
+    root: Schema.XSchemaObject;
+    lexicalSchema: Schema.XSchemaObject;
+    lexicalBase: string;
+    referenceBase: string;
+    resourceBase: string;
+    ids: Schema.XId[];
+    recursiveAnchors: Schema.XRecursiveAnchor[];
+    dynamicAnchors: Schema.XDynamicAnchor[];
+    inRetrievedFrame: boolean;
+}
+export interface RetrievedResource {
+    target: Schema.XSchemaObject;
+    base: string;
+    root: Schema.XSchemaObject;
+}
+export interface ResolvedResource {
+    target: Schema.XSchemaObject;
+    resource: Schema.XId;
+}
+export interface RefResult {
     schema: Schema.XSchema | undefined;
-    stack: Stack.XStack;
+    retrievedResource?: RetrievedResource;
+    resolvedResource?: ResolvedResource;
 }
-export declare function Ref(stack: Stack.XStack, ref: Schema.XRef): XRefResult;
-export declare function RecursiveRef(stack: Stack.XStack, recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
-export declare function DynamicRef(stack: Stack.XStack, dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;
+export declare function Base(schema: Schema.XSchemaObject, base: string, target: Schema.XSchema): string | undefined;
+export declare function Resource(context: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, base: string, ref: string): Schema.XId | undefined;
+export declare function Ref(remotes: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, base: string, ref: string, applySchemaId?: boolean): Schema.XSchema | undefined;
+export declare function DynamicRef(context: Record<string, Schema.XSchema>, root: Schema.XSchemaObject, base: string, schema: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;
+export declare function ResolveRef(stackframe: StackFrame, ref: Schema.XRef): RefResult;
+export declare function ResolveRecursiveRef(stackframe: StackFrame, recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
+export declare function ResolveDynamicRef(stackframe: StackFrame, dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;