@astrale-os/kernel-dsl 1.0.0-beta.17 → 1.0.0-beta.19

package/dist/v1/builder/class/authoring.d.ts

@@ -1,9 +1,9 @@
-import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { Array as PortableArray, Object as PortableObject, Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
 import type { ClassRef } from '../../addressing/index.js';
 import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
 import type { StateTopologyOf } from '../../language/state/topology.js';
-import type { BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
+import type { BLOB_VALUE_KIND, BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
 import type { Method, ProjectionOfCallable } from '../callable/authoring.js';
 import type { ClassProjectionOfResolved } from '../schema/projection.js';
 import type { TypedValueSchema } from '../value/schema.js';
@@ -14,8 +14,44 @@ import type { AutoProperty, Property, PropertyOptions, PropertyStateMachineOf, V
 type ExactEndpointInput<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
 type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions, unknown> ? Schema : Field;
 type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options, unknown> ? Options : Record<never, never>;
-type ValueInputOf<Schema> = Schema extends BlobSchema ? BlobReceipt : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
-type ValueOutputOf<Schema> = Schema extends BlobSchema ? BlobRef : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type JsonSchemaValueOf<Schema> = 0 extends 1 & Schema ? PortableValue : Schema extends {
+    readonly const: infer Value;
+} ? JsonKnownOf<Value> : Schema extends {
+    readonly enum: readonly (infer Value)[];
+} ? JsonKnownOf<Value> : Schema extends {
+    readonly anyOf: readonly (infer Branch)[];
+} ? JsonSchemaValueOf<Branch> : Schema extends {
+    readonly oneOf: readonly (infer Branch)[];
+} ? JsonSchemaValueOf<Branch> : Schema extends {
+    readonly type: infer Type;
+} ? JsonTypeValueOf<Type, Schema> : PortableValue;
+type JsonKnownOf<Value> = 0 extends 1 & Value ? PortableValue : Value;
+type JsonTypeValueOf<Type, Schema> = Type extends readonly (infer Each)[] ? JsonTypeValueOf<Each, Schema> : Type extends 'string' ? string : Type extends 'number' | 'integer' ? number : Type extends 'boolean' ? boolean : Type extends 'null' ? null : Type extends 'array' ? JsonArrayValueOf<Schema> : Type extends 'object' ? JsonObjectValueOf<Schema> : PortableValue;
+type JsonArrayValueOf<Schema> = 'prefixItems' extends keyof Schema ? PortableArray : Schema extends {
+    readonly items: infer Items;
+} ? readonly JsonSchemaValueOf<Items>[] : PortableArray;
+type JsonObjectValueOf<Schema> = 'patternProperties' extends keyof Schema ? PortableObject : Schema extends {
+    readonly properties: infer Properties extends Readonly<Record<string, unknown>>;
+    readonly additionalProperties: false;
+} ? JsonClosedObjectOf<Properties, Schema extends {
+    readonly required: infer Names;
+} ? Names : readonly []> : PortableObject;
+type JsonListsName<Names, Name> = [Names] extends [never] ? false : Names extends readonly unknown[] ? number extends Names['length'] ? false : true extends {
+    [At in keyof Names]: JsonNamesExactly<Names[At], Name>;
+}[number] ? true : false : false;
+type JsonNamesExactly<Element, Name> = [Element] extends [never] ? false : 0 extends 1 & Element ? false : [Element] extends [Name] ? true : false;
+type JsonClosedObjectOf<Properties, Names> = [keyof Properties] extends [never] ? Readonly<Record<string, never>> : {
+    readonly [Name in keyof Properties as JsonListsName<Names, Name> extends true ? Name : never]: JsonSchemaValueOf<Properties[Name]>;
+} & {
+    readonly [Name in keyof Properties as JsonListsName<Names, Name> extends true ? never : Name]?: JsonSchemaValueOf<Properties[Name]>;
+} extends infer Value ? {
+    [Name in keyof Value]: Value[Name];
+} : never;
+type BlobMarkedSchema = BlobSchema | {
+    readonly 'x-astrale-value-kind': typeof BLOB_VALUE_KIND;
+};
+type ValueInputOf<Schema> = Schema extends BlobMarkedSchema ? BlobReceipt : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : JsonSchemaValueOf<Schema>;
+type ValueOutputOf<Schema> = Schema extends BlobMarkedSchema ? BlobRef : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : JsonSchemaValueOf<Schema>;
 type PropertyRequiredOf<Field> = PropertyOptionsOf<Field> extends {
     readonly required: infer Required extends boolean;
 } ? Required : undefined extends ValueInputOf<PropertySchemaOf<Field>> ? false : true;

package/dist/v1/builder/class/input.d.ts

@@ -114,7 +114,7 @@ export interface NodeClassInput {
  */
 export type NodeUniqueTupleInput = readonly [string, ...string[]];
 /** Members every authored Edge Class shares. */
-export interface EdgeClassOptions {
+export interface EdgeClassCommon {
     readonly abstract?: boolean;
     /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
     readonly inheritance?: Inheritance;
@@ -138,7 +138,7 @@ export type EdgeUniqueFieldInput = 'source' | 'target' | 'slug' | {
 /** The distinct fields of one key, in any order. */
 export type EdgeUniqueTupleInput = readonly [EdgeUniqueFieldInput, ...EdgeUniqueFieldInput[]];
 /** Authored directed Edge Class. */
-export interface DirectedEdgeInput extends EdgeClassOptions {
+export interface DirectedEdgeInput extends EdgeClassCommon {
     readonly orientation: 'directed';
     readonly source: DirectedSourceInput;
     readonly target: DirectedTargetInput;
@@ -149,12 +149,11 @@ export interface DirectedEdgeInput extends EdgeClassOptions {
     readonly unique?: readonly EdgeUniqueTupleInput[];
 }
 /** Authored undirected Edge Class. */
-export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints'> {
+export interface UndirectedEdgeInput extends Omit<EdgeClassCommon, 'constraints'> {
     readonly orientation: 'undirected';
     readonly endpoints: readonly [IncidentEndpointInput, IncidentEndpointInput];
     readonly constraints?: {
         readonly noSelf?: true;
     };
 }
-export type EdgeClassCommon = EdgeClassOptions;
 export type EdgeClassInput = DirectedEdgeInput | UndirectedEdgeInput;

package/dist/v1/domain/model/domain.d.ts

@@ -1,11 +1,6 @@
 import type { DefinitionKey, DefinitionRef, Key, Revision } from '../../addressing/index.js';
 import type { DomainDependency } from '../../addressing/index.js';
-import type { MethodOwnerKeyOf, ResolvedCallable, ResolvedFunction } from '../../language/callable/resolved.js';
-import type { AnyResolvedClass } from '../../language/class/resolved.js';
-import type { ResolvedCoreDefinition, ResolvedCoreEdge } from '../../language/core/resolved.js';
-import type { ResolvedPolicy } from '../../language/policy/resolved.js';
-import type { ResolvedDefinition, ResolvedDefinitionOf } from '../../language/resolved.js';
-import type { ResolvedView } from '../../language/view/resolved.js';
+import type { AnyResolvedClass, MethodOwnerKeyOf, PropertyInputOf, ResolvedCallable, ResolvedCoreDefinition, ResolvedCoreEdge, ResolvedDefinition, ResolvedDefinitionOf, ResolvedFunction, ResolvedPolicy, ResolvedView } from '../../language/index.js';
 export type ClassNamespace<Classes extends Readonly<Record<string, unknown>> = Readonly<Record<string, AnyResolvedClass>>> = Readonly<Classes>;
 export type FunctionNamespace<Functions extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedFunction>>> = Readonly<Functions>;
 export type PolicyNamespace<Policies extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedPolicy>>> = Readonly<Policies>;
@@ -53,6 +48,6 @@ export type MethodOwnerOf<Work extends Domain, Method> = Extract<ClassesOf<Work>
 export type FunctionsOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, infer Functions> ? Functions : never;
 export type PoliciesOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, infer Policies> ? Policies : never;
 export type ViewsOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, infer Views> ? Views : never;
-export type PropertyInputFor<Class extends AnyResolvedClass> = import('../../language/class/resolved.js').PropertyInputOf<Class>;
+export type PropertyInputFor<Class extends AnyResolvedClass> = PropertyInputOf<Class>;
 export type PropertyValuesFor<Class extends AnyResolvedClass> = ReturnType<Class['properties']['from']>;
 export {};

package/dist/v1/schema/compatibility/model.d.ts

@@ -1,7 +1,6 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
 import type { Definition, Key, Revision } from '../../addressing/index.js';
 import type { DomainSchema } from '../model/schema.js';
-import type { ReferenceSite } from '../resolution/origins.js';
 import type { MeaningDifference } from './diff.js';
 export type Fingerprint = `sha256:${string}`;
 /**
@@ -56,7 +55,7 @@ export interface Subject {
 export interface Usage {
     readonly source: SchemaIdentity;
     readonly key?: Key;
-    readonly relation: ReferenceSite | 'member' | 'abstract' | 'selection' | 'capability';
+    readonly relation: 'extends' | 'core' | 'endpoint' | 'value' | 'policy' | 'pattern' | 'member' | 'abstract' | 'selection' | 'capability';
 }
 export type Facet = 'class.reference' | 'class.inherit' | 'class.composition' | 'class.properties' | 'class.endpoints' | 'class.inheritance' | 'property' | 'property.required' | 'method.existence' | 'method.object' | 'method.inheritance' | 'method.signature' | 'function.existence' | 'function.signature' | 'policy' | 'view' | 'core';
 /** A fact about a compared facet, including unchanged facets. No admission decision is implied. */

package/dist/v1/schema/model/schema.d.ts

@@ -28,7 +28,8 @@ export interface DomainSchemaIR {
  * its in-process proofs. The structure the Kernel enforces has this type, which the build checks
  * (`validation/domain.structure.typecheck.ts`), and the published JSON Schema describes it.
  */
-export type DomainSchemaDocument = DocumentOf<DomainSchemaIR>;
+export interface DomainSchemaDocument extends DocumentOf<DomainSchemaIR> {
+}
 /**
  * The JSON document a model type describes. A `Revision` and `PropertyValues` are in-process
  * proofs: the document carries them as plain text and plain values.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.17",
+  "version": "1.0.0-beta.19",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -79,6 +79,10 @@
       "types": "./dist/v1/schema/revision.d.ts",
       "import": "./dist/v1/schema/revision.js"
     },
+    "./v1/schema/values": {
+      "types": "./dist/v1/schema/validation/value-api.d.ts",
+      "import": "./dist/v1/schema/validation/value-api.js"
+    },
     "./v1/schema/domain-schema.schema.json": "./dist/v1/schema/.spec/schemas/domain-schema.schema.json",
     "./v1/schema/value-schema.schema.json": "./dist/v1/language/.spec/schemas/value-schema.schema.json",
     "./v1/schema/draft-2020-12.schema.json": "./dist/v1/language/.spec/schemas/draft-2020-12.schema.json",