@astrale-os/kernel-core 0.4.1

package/dist/domain/accessors/group.js

@@ -0,0 +1,111 @@
+/**
+ * Group a flat input record into the storage shape that mutation ports expect.
+ *
+ * Inverse of `flattenProperties` (and a sibling of `unflattenProperties`).
+ * `groupProperties` is the **write-side** entry point: callers hand in a
+ * domain-friendly flat record and get back `{ attrs, props }`, ready to
+ * spread into `graph.createNode` / `graph.updateNode`.
+ *
+ * Three accepted key shapes per entry (parsed by `parsePropertyShortcut`):
+ *   - bare              — `'color'`                                            (class-own props ONLY)
+ *   - owner-qualified   — `'Tag.color'` / `'Named.name'`                       (class or interface owner)
+ *   - domain-qualified  — `'kernel.astrale.ai:Named.name'`                     (cross-domain disambiguation)
+ *   - storage key       — `'kernel.astrale.ai:interface.Named.property.name'`  (= `K.Named.name.key`)
+ *
+ * Error model:
+ *   - bare key for an inherited prop → `UnknownPropertyError` (must qualify)
+ *   - unknown owner / prop           → `UnknownPropertyError`
+ *   - owner-qualified, owner exists in two imported domains → `AmbiguousOwnerAcrossDomainsError`
+ */
+import { parsePropertyShortcut } from './shortcut';
+export class UnknownPropertyError extends Error {
+    className;
+    propName;
+    name = 'UnknownPropertyError';
+    constructor(className, propName) {
+        super(`Unknown property "${propName}" on class "${className}"`);
+        this.className = className;
+        this.propName = propName;
+    }
+}
+export class AmbiguousOwnerAcrossDomainsError extends Error {
+    className;
+    ownerName;
+    domains;
+    name = 'AmbiguousOwnerAcrossDomainsError';
+    constructor(className, ownerName, domains) {
+        super(`Owner "${ownerName}" on class "${className}" exists in multiple domains — ` +
+            `${domains.map((d) => `"${d}"`).join(', ')}. Qualify with the domain prefix, ` +
+            `e.g. "${domains[0]}:${ownerName}.<propName>".`);
+        this.className = className;
+        this.ownerName = ownerName;
+        this.domains = domains;
+    }
+}
+/**
+ * Group a flat input record into `{ attrs, props }` per the class's property mapping.
+ *
+ * @param byClass — the per-class slice of `DomainPropertyIndex.byClass`:
+ *                  `ownerDomain → ownerName → propName → PropertyMapping`.
+ * @param className — the class being grouped (for error messages and class-own routing).
+ * @param ownDomain — the domain that owns `className`. Used to resolve bare keys
+ *                    (which must be class-own).
+ * @param flat — domain-friendly input.
+ */
+export function groupProperties(byClass, className, ownDomain, flat) {
+    const attrs = {};
+    const props = {};
+    for (const [rawKey, value] of Object.entries(flat)) {
+        const shortcut = parsePropertyShortcut(rawKey);
+        const mapping = resolveShortcut(byClass, className, ownDomain, rawKey, shortcut);
+        route(mapping, value, attrs, props);
+    }
+    return { attrs, props };
+}
+/** Resolve a parsed shortcut against the class's property index. */
+function resolveShortcut(byClass, className, ownDomain, rawKey, shortcut) {
+    switch (shortcut.kind) {
+        case 'bare': {
+            const mapping = byClass[ownDomain]?.[className]?.[shortcut.prop];
+            if (!mapping)
+                throw new UnknownPropertyError(className, rawKey);
+            return mapping;
+        }
+        case 'domain':
+        case 'qualified': {
+            const mapping = byClass[shortcut.domain]?.[shortcut.owner]?.[shortcut.prop];
+            if (!mapping)
+                throw new UnknownPropertyError(className, rawKey);
+            return mapping;
+        }
+        case 'owner': {
+            // The same Owner name can be exported by two different imported domains;
+            // surface that as an explicit error so callers escalate to domain-qualified.
+            const matches = [];
+            for (const [domain, byOwner] of Object.entries(byClass)) {
+                const m = byOwner[shortcut.owner]?.[shortcut.prop];
+                if (m)
+                    matches.push({ domain, mapping: m });
+            }
+            if (matches.length === 0)
+                throw new UnknownPropertyError(className, rawKey);
+            if (matches.length > 1) {
+                throw new AmbiguousOwnerAcrossDomainsError(className, shortcut.owner, matches.map((m) => m.domain));
+            }
+            return matches[0].mapping;
+        }
+    }
+}
+function route(mapping, value, attrs, props) {
+    if (mapping.isAttribute) {
+        attrs[mapping.propName] = value;
+        return;
+    }
+    const { domain, owner, propName } = mapping;
+    if (!props[domain])
+        props[domain] = {};
+    if (!props[domain][owner])
+        props[domain][owner] = {};
+    props[domain][owner][propName] = value;
+}
+//# sourceMappingURL=group.js.map

package/dist/domain/accessors/group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.js","sourceRoot":"","sources":["../../../domain/accessors/group.ts"],"names":[],"mappings":"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"}

package/dist/domain/accessors/index.d.ts

@@ -0,0 +1,10 @@
+export { AmbiguousInterfaceError, AmbiguousMethodError } from './errors';
+export type { AccessorNode, Attributes, BoundAccessorMethods, EdgeDraft, FlatProperties, GroupedProps, MethodDispatch, NodeDraft, Properties, PropsOf, Result, ValidationError, } from './types';
+export type { MethodMapInput } from './methods';
+export { deriveMethodCounts, createMethodCallable } from './methods';
+export { buildAccessorNode, type NodeIdentity } from './node';
+export { deriveInterfaceCounts } from './interface-counts';
+export { bindAccessorMethods } from './bind';
+export { flattenProperties, unflattenProperties } from './flatten';
+export { groupProperties, UnknownPropertyError, AmbiguousOwnerAcrossDomainsError, type ClassPropertyIndex, } from './group';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/accessors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../domain/accessors/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAExE,YAAY,EACV,YAAY,EACZ,UAAU,EACV,oBAAoB,EACpB,SAAS,EACT,cAAc,EACd,YAAY,EACZ,cAAc,EACd,SAAS,EACT,UAAU,EACV,OAAO,EACP,MAAM,EACN,eAAe,GAChB,MAAM,SAAS,CAAA;AAChB,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC/C,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AACpE,OAAO,EAAE,iBAAiB,EAAE,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAA;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAClE,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,gCAAgC,EAChC,KAAK,kBAAkB,GACxB,MAAM,SAAS,CAAA"}

package/dist/domain/accessors/index.js

@@ -0,0 +1,9 @@
+// Errors
+export { AmbiguousInterfaceError, AmbiguousMethodError } from './errors';
+export { deriveMethodCounts, createMethodCallable } from './methods';
+export { buildAccessorNode } from './node';
+export { deriveInterfaceCounts } from './interface-counts';
+export { bindAccessorMethods } from './bind';
+export { flattenProperties, unflattenProperties } from './flatten';
+export { groupProperties, UnknownPropertyError, AmbiguousOwnerAcrossDomainsError, } from './group';
+//# sourceMappingURL=index.js.map

package/dist/domain/accessors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../domain/accessors/index.ts"],"names":[],"mappings":"AAAA,SAAS;AACT,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAiBxE,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AACpE,OAAO,EAAE,iBAAiB,EAAqB,MAAM,QAAQ,CAAA;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAClE,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,gCAAgC,GAEjC,MAAM,SAAS,CAAA"}

package/dist/domain/accessors/interface-counts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Interface-name → owning-domains derivation for ambiguity detection.
+ */
+import type { DomainOrigin } from '#domain/origin';
+/**
+ * Given a class's entry in `DomainPropertyIndex.byClass`, derive the
+ * interface-name → owning-domains map used by `buildAccessorNode` for
+ * ambiguity detection.
+ *
+ * `classProps` has shape `ownerDomain → ownerName → propName → PropertyMapping`.
+ * Class-own owners (where `isAttribute === true`) are excluded — they live
+ * under `node.attrs`, not under interface-sugar keys.
+ */
+export declare function deriveInterfaceCounts(classProps: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, {
+    readonly domain: DomainOrigin;
+    readonly isAttribute: boolean;
+}>>>>>>): ReadonlyMap<string, readonly string[]>;
+//# sourceMappingURL=interface-counts.d.ts.map

package/dist/domain/accessors/interface-counts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface-counts.d.ts","sourceRoot":"","sources":["../../../domain/accessors/interface-counts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,QAAQ,CAClB,MAAM,CACJ,MAAM,EACN,QAAQ,CACN,MAAM,CACJ,MAAM,EACN,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,CAC3F,CACF,CACF,CACF,GACA,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAkBxC"}

package/dist/domain/accessors/interface-counts.js

@@ -0,0 +1,33 @@
+/**
+ * Interface-name → owning-domains derivation for ambiguity detection.
+ */
+/**
+ * Given a class's entry in `DomainPropertyIndex.byClass`, derive the
+ * interface-name → owning-domains map used by `buildAccessorNode` for
+ * ambiguity detection.
+ *
+ * `classProps` has shape `ownerDomain → ownerName → propName → PropertyMapping`.
+ * Class-own owners (where `isAttribute === true`) are excluded — they live
+ * under `node.attrs`, not under interface-sugar keys.
+ */
+export function deriveInterfaceCounts(classProps) {
+    const counts = new Map();
+    for (const [domain, byOwner] of Object.entries(classProps)) {
+        for (const [ownerName, propMap] of Object.entries(byOwner)) {
+            const sample = Object.values(propMap)[0];
+            if (!sample)
+                continue;
+            if (sample.isAttribute)
+                continue;
+            if (!counts.has(ownerName))
+                counts.set(ownerName, new Set());
+            counts.get(ownerName).add(domain);
+        }
+    }
+    const result = new Map();
+    for (const [name, domains] of counts) {
+        result.set(name, [...domains]);
+    }
+    return result;
+}
+//# sourceMappingURL=interface-counts.js.map

package/dist/domain/accessors/interface-counts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface-counts.js","sourceRoot":"","sources":["../../../domain/accessors/interface-counts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB,CACnC,UAUC;IAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAAuB,CAAA;IAE7C,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QAC3D,KAAK,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3D,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAA;YACxC,IAAI,CAAC,MAAM;gBAAE,SAAQ;YACrB,IAAI,MAAM,CAAC,WAAW;gBAAE,SAAQ;YAChC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;gBAAE,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,GAAG,EAAE,CAAC,CAAA;YAC5D,MAAM,CAAC,GAAG,CAAC,SAAS,CAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QACpC,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAA6B,CAAA;IACnD,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,MAAM,EAAE,CAAC;QACrC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAA;IAChC,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/domain/accessors/methods.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Method callable wiring for accessor nodes.
+ *
+ * Provides the method map input shape, method count derivation for
+ * top-level ambiguity detection, and callable factory.
+ */
+import type { DefRef } from '@astrale-os/kernel-dsl';
+import type { ResolvedMethod } from '#domain/compile/method/types';
+import type { NodeId } from '#ids';
+import type { MethodDispatch } from './types';
+/**
+ * Pre-computed method information passed to `buildAccessorNode` when
+ * method callables should be wired onto the node.
+ */
+export interface MethodMapInput {
+    /**
+     * defRef (`class.X` / `interface.X`) → methodName → ResolvedMethod.
+     * Keyed by the kind-qualified ref (NOT the bare name) so a class and an
+     * interface that share a name (e.g. `Function`) each get their own bucket
+     * — no silent collision at the map level.
+     */
+    readonly byOwner: ReadonlyMap<DefRef, ReadonlyMap<string, ResolvedMethod>>;
+    /** ownerName (bare) → domain origin that owns this definition */
+    readonly ownerDomains: ReadonlyMap<string, string>;
+    readonly dispatch: MethodDispatch;
+    readonly nodeId: NodeId;
+}
+/**
+ * Derive method-name → owning-defRefs map for top-level ambiguity detection.
+ *
+ * A method name that appears across multiple defRefs is ambiguous at the
+ * node's top level. The caller must use `node.TypeName.method()` or
+ * `node.$d(domain).TypeName.method()` to disambiguate.
+ */
+export declare function deriveMethodCounts(methodsByOwner: ReadonlyMap<DefRef, ReadonlyMap<string, ResolvedMethod>>): ReadonlyMap<string, readonly DefRef[]>;
+/** Wrap a single method into a dispatch-bound callable. */
+export declare function createMethodCallable(nodeId: NodeId, methodRef: string, dispatch: MethodDispatch): (args?: unknown) => Promise<unknown>;
+//# sourceMappingURL=methods.d.ts.map

package/dist/domain/accessors/methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.ts","sourceRoot":"","sources":["../../../domain/accessors/methods.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAA;IAC1E,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClD,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,GACvE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAexC;AAED,2DAA2D;AAC3D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,cAAc,GACvB,CAAC,IAAI,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAEtC"}

package/dist/domain/accessors/methods.js

@@ -0,0 +1,33 @@
+/**
+ * Method callable wiring for accessor nodes.
+ *
+ * Provides the method map input shape, method count derivation for
+ * top-level ambiguity detection, and callable factory.
+ */
+/**
+ * Derive method-name → owning-defRefs map for top-level ambiguity detection.
+ *
+ * A method name that appears across multiple defRefs is ambiguous at the
+ * node's top level. The caller must use `node.TypeName.method()` or
+ * `node.$d(domain).TypeName.method()` to disambiguate.
+ */
+export function deriveMethodCounts(methodsByOwner) {
+    const counts = new Map();
+    for (const [ownerRef, methods] of methodsByOwner) {
+        for (const methodName of methods.keys()) {
+            if (!counts.has(methodName))
+                counts.set(methodName, new Set());
+            counts.get(methodName).add(ownerRef);
+        }
+    }
+    const result = new Map();
+    for (const [name, refs] of counts) {
+        result.set(name, [...refs]);
+    }
+    return result;
+}
+/** Wrap a single method into a dispatch-bound callable. */
+export function createMethodCallable(nodeId, methodRef, dispatch) {
+    return (args) => dispatch(nodeId, methodRef, args);
+}
+//# sourceMappingURL=methods.js.map

package/dist/domain/accessors/methods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.js","sourceRoot":"","sources":["../../../domain/accessors/methods.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2BH;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,cAAwE;IAExE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAuB,CAAA;IAE7C,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,cAAc,EAAE,CAAC;QACjD,KAAK,MAAM,UAAU,IAAI,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;YACxC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC;gBAAE,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,GAAG,EAAE,CAAC,CAAA;YAC9D,MAAM,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QACvC,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAA6B,CAAA;IACnD,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,EAAE,CAAC;QAClC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAA;IAC7B,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,oBAAoB,CAClC,MAAc,EACd,SAAiB,EACjB,QAAwB;IAExB,OAAO,CAAC,IAAc,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,CAAA;AAC9D,CAAC"}

package/dist/domain/accessors/node.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Accessor node builder — constructs rich nodes with $d() sugar,
+ * interface property access, and optional method callables.
+ */
+import type { ClassPath } from '#domain/addressing/paths';
+import type { AbsolutePath } from '#graph/tree';
+import type { NodeId } from '#ids';
+import type { AccessorNode, Attributes, GroupedProps } from './types';
+import { type MethodMapInput } from './methods';
+/** Identity carried on every AccessorNode — a Node projected to its identity triple. */
+export interface NodeIdentity {
+    readonly id: NodeId;
+    readonly path: AbsolutePath;
+    readonly class: ClassPath;
+}
+/**
+ * Build a rich accessor node from identity + split property groups.
+ *
+ * Interface sugar (`node.Named.name`) is wired for names defined by
+ * exactly one domain. Ambiguous names throw on access.
+ *
+ * When `methodMap` is provided, methods are wired as callables in
+ * their owning definition's namespace and at the top level (when unambiguous).
+ */
+export declare function buildAccessorNode(identity: NodeIdentity, attrs: Attributes, grouped: GroupedProps, interfaceCounts: ReadonlyMap<string, readonly string[]>, methodMap?: MethodMapInput): AccessorNode;
+//# sourceMappingURL=node.d.ts.map

package/dist/domain/accessors/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../domain/accessors/node.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAGrE,OAAO,EAA4C,KAAK,cAAc,EAAE,MAAM,WAAW,CAAA;AAEzF,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAC1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,YAAY,EACrB,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,EACvD,SAAS,CAAC,EAAE,cAAc,GACzB,YAAY,CA0Gd"}

package/dist/domain/accessors/node.js

@@ -0,0 +1,111 @@
+/**
+ * Accessor node builder — constructs rich nodes with $d() sugar,
+ * interface property access, and optional method callables.
+ */
+import { parseDefRef } from '@astrale-os/kernel-dsl';
+import { Ref } from '#domain/addressing/refs/ref';
+import { AmbiguousInterfaceError, AmbiguousMethodError } from './errors';
+import { createMethodCallable, deriveMethodCounts } from './methods';
+/**
+ * Build a rich accessor node from identity + split property groups.
+ *
+ * Interface sugar (`node.Named.name`) is wired for names defined by
+ * exactly one domain. Ambiguous names throw on access.
+ *
+ * When `methodMap` is provided, methods are wired as callables in
+ * their owning definition's namespace and at the top level (when unambiguous).
+ */
+export function buildAccessorNode(identity, attrs, grouped, interfaceCounts, methodMap) {
+    const node = {
+        id: identity.id,
+        path: identity.path,
+        class: identity.class,
+        attrs,
+    };
+    // Build mutable domain data from grouped properties
+    const domainData = {};
+    for (const [domain, interfaces] of Object.entries(grouped)) {
+        domainData[domain] = {};
+        for (const [iface, props] of Object.entries(interfaces)) {
+            domainData[domain][iface] = { ...props };
+        }
+    }
+    // Merge method callables into domain data
+    if (methodMap) {
+        // byOwner is defRef-keyed (`class.X` / `interface.X`) so a class and an
+        // interface sharing a name (e.g. `Function`) each get their own bucket.
+        // The kind that qualifies the method ref is in the key — no per-method
+        // disambiguation needed.
+        for (const [ownerRef, methods] of methodMap.byOwner) {
+            const { kind: ownerKind, name: ownerName } = parseDefRef(ownerRef);
+            const domain = methodMap.ownerDomains.get(ownerName) ?? '';
+            if (!domainData[domain])
+                domainData[domain] = {};
+            if (!domainData[domain][ownerName])
+                domainData[domain][ownerName] = {};
+            for (const methodName of methods.keys()) {
+                domainData[domain][ownerName][methodName] = createMethodCallable(methodMap.nodeId, Ref.method(ownerKind, ownerName, methodName).toString(), methodMap.dispatch);
+            }
+        }
+    }
+    // $d() — always available, always unambiguous
+    node.$d = (domain) => domainData[domain] ?? {};
+    // Interface sugar — direct keys when unambiguous
+    for (const [interfaceName, domains] of interfaceCounts) {
+        if (domains.length === 1) {
+            const [soleDomain] = domains;
+            if (soleDomain !== undefined) {
+                node[interfaceName] = domainData[soleDomain]?.[interfaceName] ?? {};
+            }
+        }
+        else {
+            Object.defineProperty(node, interfaceName, {
+                get() {
+                    throw new AmbiguousInterfaceError(interfaceName, domains);
+                },
+                enumerable: true,
+                configurable: false,
+            });
+        }
+    }
+    // Method-only definition sugar — definitions with methods but no properties
+    if (methodMap) {
+        for (const [ownerRef, methods] of methodMap.byOwner) {
+            const { name: ownerName } = parseDefRef(ownerRef);
+            if (ownerName in node)
+                continue;
+            if (methods.size === 0)
+                continue;
+            const domain = methodMap.ownerDomains.get(ownerName);
+            if (domain && domainData[domain]?.[ownerName]) {
+                node[ownerName] = domainData[domain][ownerName];
+            }
+        }
+        // Top-level method sugar — when unambiguous across owner defRefs. Both kind
+        // and bare name come from the parsed defRef key, so there is no `?? 'class'`
+        // fallback to construct: the disambiguation is structural.
+        const methodCounts = deriveMethodCounts(methodMap.byOwner);
+        for (const [methodName, owners] of methodCounts) {
+            if (methodName in node)
+                continue;
+            if (owners.length === 1) {
+                const [soleOwnerRef] = owners;
+                if (soleOwnerRef !== undefined) {
+                    const { kind, name } = parseDefRef(soleOwnerRef);
+                    node[methodName] = createMethodCallable(methodMap.nodeId, Ref.method(kind, name, methodName).toString(), methodMap.dispatch);
+                }
+            }
+            else {
+                Object.defineProperty(node, methodName, {
+                    get() {
+                        throw new AmbiguousMethodError(methodName, [...owners]);
+                    },
+                    enumerable: true,
+                    configurable: false,
+                });
+            }
+        }
+    }
+    return node;
+}
+//# sourceMappingURL=node.js.map

package/dist/domain/accessors/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../domain/accessors/node.ts"],"names":[],"mappings":"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"}

package/dist/domain/accessors/shortcut.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Property shortcut grammar — the domain-friendly user-input format for
+ * addressing a property on a class.
+ *
+ * Four shapes:
+ *   - bare      — `'color'`                                           (target inferred from class)
+ *   - owner     — `'Tag.color'` / `'Named.name'`                      (owner explicit, domain inferred)
+ *   - domain    — `'kernel.astrale.ai:Named.name'`                    (owner + domain)
+ *   - qualified  — `'kernel.astrale.ai:interface.Named.property.name'` (fully-qualified ref —
+ *                                                                      same shape as `K.<Owner>.<prop>.key`)
+ *
+ * `qualified` accepts the exact string produced by `K.*.key` so callers can use
+ * the typed accessor at mutation sites:
+ *
+ *   await graph.updateNode({ ..., props: { [K.Identity.iss.key]: iss } })
+ *
+ * Grammar tokens are reused from their canonical owners: `:` from key
+ * construction (`DOMAIN_SEP`), `.` from ref segmentation (`SEGMENT_SEP`),
+ * and the namespace set + `property` marker from Ref via `Ref.parse`.
+ *
+ * NOTE — publishing the qualified-ref shape as an input grammar means any
+ * future change to that format (the `<namespace>.<Owner>.property.<prop>`
+ * layout owned by Ref) becomes a breaking change for callers. Change the
+ * parser and `K.*.key` together.
+ */
+export type PropertyShortcut = {
+    readonly kind: 'bare';
+    readonly prop: string;
+} | {
+    readonly kind: 'owner';
+    readonly owner: string;
+    readonly prop: string;
+} | {
+    readonly kind: 'domain';
+    readonly domain: string;
+    readonly owner: string;
+    readonly prop: string;
+} | {
+    readonly kind: 'qualified';
+    readonly domain: string;
+    readonly owner: string;
+    readonly prop: string;
+};
+export declare class PropertyShortcutParseError extends Error {
+    readonly raw: string;
+    readonly name = "PropertyShortcutParseError";
+    constructor(raw: string, reason: string);
+}
+/**
+ * Parse a property shortcut into its discriminated form.
+ *
+ * Throws `PropertyShortcutParseError` only on structurally invalid inputs
+ * (empty owner / prop after a separator, malformed storage key). Existence of
+ * the owner / property is validated by the caller against the property index.
+ */
+export declare function parsePropertyShortcut(raw: string): PropertyShortcut;
+//# sourceMappingURL=shortcut.d.ts.map

package/dist/domain/accessors/shortcut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut.d.ts","sourceRoot":"","sources":["../../../domain/accessors/shortcut.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAMH,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzE;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAA;AAEL,qBAAa,0BAA2B,SAAQ,KAAK;IAGjD,QAAQ,CAAC,GAAG,EAAE,MAAM;IAFtB,SAAkB,IAAI,gCAA+B;IACrD,YACW,GAAG,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EAGf;CACF;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CA2CnE"}

package/dist/domain/accessors/shortcut.js

@@ -0,0 +1,87 @@
+/**
+ * Property shortcut grammar — the domain-friendly user-input format for
+ * addressing a property on a class.
+ *
+ * Four shapes:
+ *   - bare      — `'color'`                                           (target inferred from class)
+ *   - owner     — `'Tag.color'` / `'Named.name'`                      (owner explicit, domain inferred)
+ *   - domain    — `'kernel.astrale.ai:Named.name'`                    (owner + domain)
+ *   - qualified  — `'kernel.astrale.ai:interface.Named.property.name'` (fully-qualified ref —
+ *                                                                      same shape as `K.<Owner>.<prop>.key`)
+ *
+ * `qualified` accepts the exact string produced by `K.*.key` so callers can use
+ * the typed accessor at mutation sites:
+ *
+ *   await graph.updateNode({ ..., props: { [K.Identity.iss.key]: iss } })
+ *
+ * Grammar tokens are reused from their canonical owners: `:` from key
+ * construction (`DOMAIN_SEP`), `.` from ref segmentation (`SEGMENT_SEP`),
+ * and the namespace set + `property` marker from Ref via `Ref.parse`.
+ *
+ * NOTE — publishing the qualified-ref shape as an input grammar means any
+ * future change to that format (the `<namespace>.<Owner>.property.<prop>`
+ * layout owned by Ref) becomes a breaking change for callers. Change the
+ * parser and `K.*.key` together.
+ */
+import { DOMAIN_SEP } from '#domain/addressing/grammar/tokens';
+import { isNamespace } from '#domain/addressing/namespace';
+import { Ref, SEGMENT_SEP } from '#domain/addressing/refs/ref';
+export class PropertyShortcutParseError extends Error {
+    raw;
+    name = 'PropertyShortcutParseError';
+    constructor(raw, reason) {
+        super(`Invalid property shortcut "${raw}": ${reason}`);
+        this.raw = raw;
+    }
+}
+/**
+ * Parse a property shortcut into its discriminated form.
+ *
+ * Throws `PropertyShortcutParseError` only on structurally invalid inputs
+ * (empty owner / prop after a separator, malformed storage key). Existence of
+ * the owner / property is validated by the caller against the property index.
+ */
+export function parsePropertyShortcut(raw) {
+    const colonIdx = raw.indexOf(DOMAIN_SEP);
+    if (colonIdx !== -1) {
+        const domain = raw.slice(0, colonIdx);
+        const tail = raw.slice(colonIdx + 1);
+        if (domain.length === 0)
+            throw new PropertyShortcutParseError(raw, 'empty domain');
+        // Discriminate `qualified` vs `domain`: the qualified form starts with a
+        // namespace token (`class` | `interface` | `core`). Legitimate Owner names
+        // are PascalCase and never collide with these lowercase markers.
+        const firstDot = tail.indexOf(SEGMENT_SEP);
+        if (firstDot !== -1 && isNamespace(tail.slice(0, firstDot))) {
+            const ref = Ref.tryParse(tail);
+            if (!ref || !ref.isProperty) {
+                throw new PropertyShortcutParseError(raw, 'qualified ref must address a property (expected `<namespace>.<Owner>.property.<prop>`)');
+            }
+            return { kind: 'qualified', domain, owner: ref.member, prop: ref.child };
+        }
+        const tailDot = firstDot;
+        if (tailDot === -1)
+            throw new PropertyShortcutParseError(raw, 'missing owner segment');
+        const owner = tail.slice(0, tailDot);
+        const prop = tail.slice(tailDot + 1);
+        if (owner.length === 0)
+            throw new PropertyShortcutParseError(raw, 'empty owner');
+        if (prop.length === 0)
+            throw new PropertyShortcutParseError(raw, 'empty prop');
+        return { kind: 'domain', domain, owner, prop };
+    }
+    const dotIdx = raw.indexOf(SEGMENT_SEP);
+    if (dotIdx === -1) {
+        if (raw.length === 0)
+            throw new PropertyShortcutParseError(raw, 'empty key');
+        return { kind: 'bare', prop: raw };
+    }
+    const owner = raw.slice(0, dotIdx);
+    const prop = raw.slice(dotIdx + 1);
+    if (owner.length === 0)
+        throw new PropertyShortcutParseError(raw, 'empty owner');
+    if (prop.length === 0)
+        throw new PropertyShortcutParseError(raw, 'empty prop');
+    return { kind: 'owner', owner, prop };
+}
+//# sourceMappingURL=shortcut.js.map

package/dist/domain/accessors/shortcut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut.js","sourceRoot":"","sources":["../../../domain/accessors/shortcut.ts"],"names":[],"mappings":"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"}