@astrale-os/kernel-dsl 1.0.0-beta.10 → 1.0.0-beta.11

package/dist/v1/addressing/class-key.js

@@ -10,11 +10,11 @@ export function ClassKey(input) {
 /** Construction, admission, and structural-coordinate operations for exact Class keys. */
 (function (ClassKey) {
     function of(ref) {
-        const admitted = acceptDefinitionRef(ref);
-        if (admitted.kind !== 'class') {
+        const key = Key.of(ref);
+        if (!key.slice(key.indexOf(':') + 1).startsWith('class.')) {
             throw new TypeError(`Invalid ClassKey coordinate: ${JSON.stringify(ref)}.`);
         }
-        return Key.of(admitted);
+        return key;
     }
     ClassKey.of = of;
     function is(input) {

package/dist/v1/addressing/key.d.ts

@@ -12,7 +12,10 @@ export declare namespace Key {
     type Definition<Kind extends DefinitionKind = DefinitionKind, Name extends string = string, Origin extends Key.Origin = Key.Origin> = DefinitionKey<Origin, Kind, Name>;
     type Callable = DefinitionKey<Key.Origin, 'function'> | MethodKey;
     type View = DefinitionKey<Key.Origin, 'view'>;
-    /** Derive a canonical Definition key from its structured coordinate. */
+    /**
+     * Derive a canonical Definition key from its structured coordinate. A frozen coordinate of data
+     * fields cannot change, so its key is derived once and read back for every later call.
+     */
     function of<const Ref extends DefinitionRef>(ref: Ref): DefinitionKey<Ref['origin'], Ref['kind'], Ref['name']>;
     function origin(input: Key): Key.Origin;
     function is(input: unknown): input is Key;

package/dist/v1/addressing/key.js

@@ -3,6 +3,8 @@ import { DOMAIN_ORIGIN_PATTERN } from './patterns.js';
 const DEFINITION_KEY = /^(?:class|function|policy|view)\.([A-Za-z][A-Za-z0-9_]*)$/u;
 const CORE_KEY = /^core\.([a-z][a-z0-9-]{0,99})$/u;
 const MEMBER_KEY = /^class\.([A-Za-z][A-Za-z0-9_]*)\.(property|method)\.([A-Za-z][A-Za-z0-9_]*)$/u;
+/** The keys of frozen Definition coordinates, derived once each. */
+const derived = new WeakMap();
 export function Key(input) {
     if (typeof input !== 'string' || !isCanonicalKey(input)) {
         throw new TypeError(`Invalid Key: ${JSON.stringify(input)}.`);
@@ -11,10 +13,22 @@ export function Key(input) {
 }
 /** Canonical origin-qualified address operations. */
 (function (Key) {
-    /** Derive a canonical Definition key from its structured coordinate. */
+    /**
+     * Derive a canonical Definition key from its structured coordinate. A frozen coordinate of data
+     * fields cannot change, so its key is derived once and read back for every later call.
+     */
     function of(ref) {
+        const object = typeof ref === 'object' && ref !== null;
+        const known = object ? derived.get(ref) : undefined;
+        if (known !== undefined)
+            return known;
+        // Decided before admission reads the fields: only then are the fields read the final ones.
+        const stable = object && immutable(ref);
         const definition = acceptDefinitionRef(ref);
-        return Key(`${definition.origin}:${definition.kind}.${definition.name}`);
+        const key = Key(`${definition.origin}:${definition.kind}.${definition.name}`);
+        if (stable)
+            derived.set(ref, key);
+        return key;
     }
     Key.of = of;
     function origin(input) {
@@ -37,3 +51,8 @@ function isCanonicalKey(input) {
 function isCanonicalCoordinate(input) {
     return DEFINITION_KEY.test(input) || CORE_KEY.test(input) || MEMBER_KEY.test(input);
 }
+/** A frozen object of data fields answers every read alike; a getter may not. */
+function immutable(ref) {
+    return (Object.isFrozen(ref) &&
+        Reflect.ownKeys(ref).every((key) => 'value' in Reflect.getOwnPropertyDescriptor(ref, key)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.10",
+  "version": "1.0.0-beta.11",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {