@astrale-os/kernel-dsl 0.2.0-beta.12 → 0.2.0-beta.13

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

@@ -106,7 +106,7 @@ type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Valu
 type PropertyRequiredOf<Field> = PropertyOptionsOf<Field> extends {
     readonly required: infer Required extends boolean;
 } ? Required : undefined extends ValueInputOf<PropertySchemaOf<Field>> ? false : true;
-type PropertyProjectionOf<Name extends string, Field> = AuthoredPropertyProjection<ValueInputOf<PropertySchemaOf<Field>>, ValueOutputOf<PropertySchemaOf<Field>>, PropertyRequiredOf<Field>, Name>;
+type PropertyProjectionOf<Name extends string, Field> = AuthoredPropertyProjection<Field extends AutoProperty ? never : ValueInputOf<PropertySchemaOf<Field>>, ValueOutputOf<PropertySchemaOf<Field>>, PropertyRequiredOf<Field>, Name>;
 type PropertyProjectionsOf<Input> = Input extends Readonly<Record<string, unknown>> ? {
     readonly [Name in keyof Input]: PropertyProjectionOf<Extract<Name, string>, Input[Name]>;
 } : Readonly<Record<never, never>>;

package/dist/v1/builder/schema/projection.d.ts

@@ -214,16 +214,20 @@ type AuthoredProjectionRequired<Entry> = Entry extends AuthoredPropertyProjectio
 type UniqueAuthoredProjections<Entries> = Entries extends unknown ? IsMultiple<Extract<Entries, {
     readonly name: AuthoredProjectionName<Entries>;
 }>> extends true ? never : Entries : never;
-type RequiredAuthoredPropertyNames<Entries> = UniqueAuthoredProjections<Entries> extends infer Entry ? Entry extends unknown ? AuthoredProjectionRequired<Entry> extends true ? AuthoredProjectionName<Entry> : never : never : never;
-type OptionalAuthoredPropertyNames<Entries> = Exclude<AuthoredProjectionName<UniqueAuthoredProjections<Entries>>, RequiredAuthoredPropertyNames<Entries>>;
+type CoreAuthoredProjections<Entries> = UniqueAuthoredProjections<Entries> extends infer Entry ? Entry extends unknown ? [AuthoredProjectionInput<Entry>] extends [never] ? never : Entry : never : never;
+type RequiredAuthoredPropertyNames<Entries> = CoreAuthoredProjections<Entries> extends infer Entry ? Entry extends unknown ? AuthoredProjectionRequired<Entry> extends true ? AuthoredProjectionName<Entry> : never : never : never;
+type OptionalAuthoredPropertyNames<Entries> = Exclude<AuthoredProjectionName<CoreAuthoredProjections<Entries>>, RequiredAuthoredPropertyNames<Entries>>;
+type AutomaticAuthoredPropertyNames<Entries> = UniqueAuthoredProjections<Entries> extends infer Entry ? Entry extends unknown ? [AuthoredProjectionInput<Entry>] extends [never] ? AuthoredProjectionName<Entry> : never : never : never;
 type CorePropertyInputFromAuthoredProjections<Entries> = Readonly<{
-    [Name in RequiredAuthoredPropertyNames<Entries>]: AuthoredProjectionInput<Extract<UniqueAuthoredProjections<Entries>, {
+    [Name in RequiredAuthoredPropertyNames<Entries>]: AuthoredProjectionInput<Extract<CoreAuthoredProjections<Entries>, {
         readonly name: Name;
     }>>;
 } & {
-    [Name in OptionalAuthoredPropertyNames<Entries>]?: AuthoredProjectionInput<Extract<UniqueAuthoredProjections<Entries>, {
+    [Name in OptionalAuthoredPropertyNames<Entries>]?: AuthoredProjectionInput<Extract<CoreAuthoredProjections<Entries>, {
         readonly name: Name;
     }>>;
+} & {
+    [Name in AutomaticAuthoredPropertyNames<Entries>]?: never;
 }>;
 type UnionIsMultiple<Value, Whole = Value> = Value extends unknown ? [Whole] extends [Value] ? false : true : never;
 type IsMultiple<Value> = true extends UnionIsMultiple<Value> ? true : false;

package/dist/v1/compiled/admission/semantics.js

@@ -973,10 +973,12 @@ function validateCoreProperties(values, analysis, path) {
             fail(`${path}/${escapePointer(key)}`, 'Core properties contain an unknown Property key.');
     for (const property of analysis.properties.values()) {
         if (!Object.hasOwn(values, property.key)) {
-            if (property.declaration.required)
+            if (property.declaration.required && property.declaration.auto === undefined)
                 fail(`${path}/${escapePointer(property.key)}`, 'Core properties omit a required Property.');
             continue;
         }
+        if (property.declaration.auto !== undefined)
+            fail(`${path}/${escapePointer(property.key)}`, 'Core properties cannot author an automatic Property.');
         if (validateValueProgram(property.entry.values[property.declaration.value], values[property.key])
             .length > 0)
             fail(`${path}/${escapePointer(property.key)}`, 'Core Property value does not satisfy its exact contract.');

package/dist/v1/compiled/generated.d.ts

@@ -0,0 +1,10 @@
+import type { Domain } from '../domain/model/domain.js';
+import type { CompiledSchema, DomainOfCompiled } from './model/schema.js';
+declare const GENERATED_COMPILED_SCHEMA: unique symbol;
+/** Exact compiled material embedded by an Astrale build generator. */
+export interface GeneratedCompiledSchema<Resolved = Domain> extends CompiledSchema<Resolved> {
+    readonly [GENERATED_COMPILED_SCHEMA]: 'generated-compiled-schema';
+}
+/** Realize immutable, build-owned compiled material without repeating external admission. */
+export declare function load<const Input extends GeneratedCompiledSchema>(input: Input): DomainOfCompiled<Input>;
+export {};

package/dist/v1/compiled/generated.js

@@ -0,0 +1,15 @@
+import { realize } from './loader/load.js';
+/** Realize immutable, build-owned compiled material without repeating external admission. */
+export function load(input) {
+    return realize(deepFreeze(input));
+}
+function deepFreeze(input, seen = new WeakSet()) {
+    if (input === null || typeof input !== 'object' || seen.has(input))
+        return input;
+    seen.add(input);
+    for (const value of Object.values(input))
+        deepFreeze(value, seen);
+    if (!Object.isFrozen(input))
+        Object.freeze(input);
+    return input;
+}

package/dist/v1/compiled/loader/load.d.ts

@@ -2,3 +2,8 @@ import type { CompiledSchema, DomainOfCompiled } from '../model/schema.js';
 /** Load admitted compiled data through the one resolved Domain constructor. */
 export declare function load<const Input extends CompiledSchema>(input: Input): DomainOfCompiled<Input>;
 export declare function load(input: unknown): import('../../domain/model/domain.js').Domain;
+/**
+ * Realize compiled material whose exact embedded bytes were already proven by generated build code.
+ * External bytes and caller-provided values must continue through {@link load}.
+ */
+export declare function realize(compiled: CompiledSchema): import('../../domain/model/domain.js').Domain;

package/dist/v1/compiled/loader/load.js

@@ -5,7 +5,13 @@ import { combineDomainValidation, createDomainValidation, unknownInputField, } f
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
 import { acceptCompiledSchema } from '../admission/accept.js';
 export function load(input) {
-    const compiled = acceptCompiledSchema(input);
+    return realize(acceptCompiledSchema(input));
+}
+/**
+ * Realize compiled material whose exact embedded bytes were already proven by generated build code.
+ * External bytes and caller-provided values must continue through {@link load}.
+ */
+export function realize(compiled) {
     const entries = new Map(compiled.closure.map((entry) => [entry.origin, loadEntry(entry)]));
     const root = entries.get(compiled.root.origin);
     if (root === undefined || root.entry.revision !== compiled.root.revision) {

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

@@ -68,6 +68,6 @@ export interface CompiledSchema<Resolved = Domain> {
     readonly version: 1;
     readonly root: DomainDependency;
     readonly closure: readonly CompiledSchemaEntry[];
-    readonly [COMPILED_DOMAIN]?: Resolved;
+    readonly [COMPILED_DOMAIN]: Resolved;
 }
 export type DomainOfCompiled<Value extends CompiledSchema> = Value extends CompiledSchema<infer Resolved> ? Resolved : Domain;

package/dist/v1/schema/validation/core.js

@@ -92,9 +92,11 @@ function endpointSatisfies(environment, endpoint, accepts) {
 function validateCreationProperties(definition, properties, registry, code, pointer, diagnostics) {
     const schema = {
         type: 'object',
-        properties: Object.fromEntries([...definition.properties].map(([name, field]) => [name, field.schema])),
+        properties: Object.fromEntries([...definition.properties]
+            .filter(([, field]) => field.auto === undefined)
+            .map(([name, field]) => [name, field.schema])),
         required: [...definition.properties]
-            .filter(([, field]) => field.required)
+            .filter(([, field]) => field.required && field.auto === undefined)
             .map(([name]) => name)
             .sort(compareUnicode),
         additionalProperties: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.12",
+  "version": "0.2.0-beta.13",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -43,6 +43,10 @@
       "types": "./dist/v1/compiled/index.d.ts",
       "import": "./dist/v1/compiled/index.js"
     },
+    "./v1/compiled/generated": {
+      "types": "./dist/v1/compiled/generated.d.ts",
+      "import": "./dist/v1/compiled/generated.js"
+    },
     "./v1/compiled/loader": {
       "types": "./dist/v1/compiled/loader/index.d.ts",
       "import": "./dist/v1/compiled/loader/index.js"