@astrale-os/kernel-dsl 0.2.0-beta.9 → 1.0.0-beta.2

package/dist/v1/language/value/evaluate/validate.js

@@ -1,31 +1,41 @@
 import { diagnostic } from '../../validation/diagnostic.js';
 import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
 import { evaluateInstance } from './evaluator.js';
-import { prepareValueSchema } from './preparation.js';
+import { prepareValueSchema, } from './preparation.js';
 const validatorCache = new WeakMap();
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
  *
  * Evaluation is an interpreter over the exact local resource closure. It never performs network
- * resolution or dynamic source generation, and every admitted I-Regexp executes through RE2JS.
+ * resolution or dynamic source generation; patterns use the portable executor.
  * `format` remains annotation-only; the graph NodePath codec performs its separate locator check.
  */
-export function validateJsonInstance(schema, value, registry, pointer = '') {
+export function validateJsonInstance(schema, value, registry, pointer = '', patterns) {
     const diagnostics = [...validateCanonicalJsonDomain(value, pointer)];
     if (diagnostics.length > 0)
         return diagnostics;
-    const prepared = preparedInstanceValidator(schema, registry, pointer);
-    if (prepared.kind === 'error') {
+    const prepared = preparedInstanceValidator(schema, registry, pointer, patterns);
+    if (!prepared.compiled) {
         return [
             diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Value validation failed closed while preparing exact schema resources: ${prepared.message}.`),
         ];
     }
-    const result = evaluateInstance(prepared.compiled, value);
+    return instanceDiagnostics(prepared.value, value, pointer);
+}
+/** Validate with the exact preparation already retained by a source-resolved Property or Callable. */
+export function validatePreparedInstance(compiled, value) {
+    const diagnostics = [...validateCanonicalJsonDomain(value, '')];
+    return diagnostics.length > 0
+        ? diagnostics
+        : instanceDiagnostics(compiled, value, '');
+}
+function instanceDiagnostics(compiled, value, pointer) {
+    const result = evaluateInstance(compiled, value);
     if (result.valid)
         return [];
     return result.failures.map((failure) => diagnostic('VALUE_SCHEMA_INSTANCE_INVALID', `${pointer}${failure.instancePointer}`, `Value does not satisfy its complete V1 schema at ${failure.keyword}: ${failure.message}`));
 }
-function preparedInstanceValidator(schema, registry, pointer) {
+function preparedInstanceValidator(schema, registry, pointer, patterns) {
     let bySchema = validatorCache.get(registry);
     if (bySchema === undefined) {
         bySchema = new Map();
@@ -34,10 +44,7 @@ function preparedInstanceValidator(schema, registry, pointer) {
     const cached = bySchema.get(schema);
     if (cached !== undefined)
         return cached;
-    const compilation = prepareValueSchema(schema, registry, pointer);
-    const prepared = compilation.compiled
-        ? { kind: 'validator', compiled: compilation.value }
-        : { kind: 'error', message: compilation.message };
+    const prepared = prepareValueSchema(schema, registry, pointer, patterns);
     bySchema.set(schema, prepared);
     return prepared;
 }

package/dist/v1/language/value/inclusion/includes.d.ts

@@ -0,0 +1,9 @@
+import type { ValueProgram } from '../compile/model.js';
+/**
+ * Whether `outer` admits every value `inner` admits, under the one V1 evaluator.
+ *
+ * `true` is a proof. `false` only means that no rule proved inclusion: a caller must then decide
+ * the values themselves. Each rule relates one assertion of `outer` to evidence carried by
+ * `inner`; a finite `inner` is decided exactly by evaluating its candidates.
+ */
+export declare function valueProgramIncludes(outer: ValueProgram, inner: ValueProgram): boolean;