@astrale-os/kernel-core 0.4.1

package/dist/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../kernel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAU7C,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA8B,CAAA;AAS5C,oEAAoE;AACpE,eAAO,MAAM,gBAAgB;aAC3B,SAAS;aACT,SAAS;CACD,CAAA;AAEV,iEAAiE;AACjE,eAAO,MAAM,aAAa;aACxB,MAAM;CACE,CAAA;AAEV;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,UAIhB,CAAA;AAEV;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAInD,CAAA"}

package/dist/kernel.js

@@ -0,0 +1,84 @@
+/**
+ * K — the kernel identity object.
+ *
+ * Single import for every kernel identity concern:
+ *
+ *   import { K } from '@astrale-os/kernel-core'
+ *
+ *   K.has_parent.ref              // 'class.has_parent'
+ *   K.has_parent.key              // 'kernel.astrale.ai:class.has_parent'
+ *   K.has_parent.path.domain      // DomainPath — semantic address
+ *   K.has_parent.path.absolute    // AbsolutePath — tree position
+ *   K.has_parent.path.class       // ClassPath — type identity
+ *
+ *   K.Domain.ref                  // 'class.Domain'
+ *   K.$.i('Function').path.domain // DomainPath — `Function` is a homonym, see below
+ *   K.Timestamped.createdAt.key   // 'kernel.astrale.ai:interface.Timestamped.property.createdAt'
+ *   K.$.origin                    // DomainOrigin
+ *
+ * Homonyms (a name that is BOTH a class and an interface, e.g. `Function`) are
+ * NOT on the flat surface — they require the disambiguation accessors:
+ *   K.$.c('Function'), K.$.i('Function'), K.Foo.$.p('bio'), K.Foo.$.m('describe')
+ *
+ * Lives at the top of `kernel/core/` because it is the **bridge** between
+ * the `schema/` subdomain (KernelSchema — the combinator-authored source of
+ * truth) and the `domain/` subdomain (compileDomain — the generic compiler
+ * from schema to runtime identity). Neither subdomain owns it alone;
+ * placing it here acknowledges the cross-cut and keeps both subdomains free
+ * of each other.
+ */
+import { compileDomain } from '#domain/compile/compile';
+import { KernelSchema } from '#schema';
+import { registerKernelLanguage } from './path-dsl';
+// Compile the kernel-meta domain. Typed-path factories (`ClassPath.from`,
+// etc.) used during ref construction lex against an internal grammar
+// closure, so this runs without any global registry being armed.
+export const K = compileDomain(KernelSchema);
+// Arm the global path registries from K. Single entry point — boot
+// order is explicit and grep-able. After this, `parsePath('/raw')`
+// works for all consumers that don't carry their own grammar set.
+registerKernelLanguage(K);
+// ─── Per-interface property keys ──────────────────────────────────
+/** Domain-qualified property keys for the Timestamped interface. */
+export const TIMESTAMPED_KEYS = {
+    createdAt: K.Timestamped.createdAt.key,
+    updatedAt: K.Timestamped.updatedAt.key,
+};
+/** Domain-qualified property keys for the Statused interface. */
+export const STATUSED_KEYS = {
+    status: K.Statused.status.key,
+};
+/**
+ * Concrete RemoteKeys built from the kernel schema.
+ *
+ * Maps Remotable interface property names to domain-qualified keys, e.g.
+ * "kernel.astrale.ai:interface.Remotable.property.externalId". Injected into
+ * the sync pipeline so core/graph never depends on the domain layer directly
+ * — the keys travel as plain strings through Properties.
+ */
+export const REMOTE_KEYS = {
+    externalId: K.Remotable.externalId.key,
+    updatedAt: K.Remotable.updatedAt.key,
+    onConflict: K.Remotable.onConflict.key,
+};
+/**
+ * Property keys managed by the graph backend, not by sync callers.
+ *
+ * Writes to these keys come from the adapter's push stages (see
+ * `adapters/graph/properties.ts` — `timestampsCreate`, `timestampsUpdate`,
+ * `nodeDefaults`). Including them in sync's diff view causes two classes of
+ * problems:
+ *
+ * - `replace` strategy nulls out keys on base not present on incoming —
+ *   since specs never emit these, `createdAt` / `status` get destroyed.
+ * - `merge` strategy echoes them back in patches the adapter will
+ *   immediately overwrite with its own stamp — wasted writes.
+ *
+ * Compare must strip these from both sides before diffing.
+ */
+export const SYSTEM_PROPERTY_KEYS = new Set([
+    'id',
+    ...Object.values(TIMESTAMPED_KEYS),
+    ...Object.values(STATUSED_KEYS),
+]);
+//# sourceMappingURL=kernel.js.map

package/dist/kernel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.js","sourceRoot":"","sources":["../kernel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEtC,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAEnD,0EAA0E;AAC1E,qEAAqE;AACrE,iEAAiE;AACjE,MAAM,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC,YAAY,CAAC,CAAA;AAE5C,mEAAmE;AACnE,mEAAmE;AACnE,kEAAkE;AAClE,sBAAsB,CAAC,CAAC,CAAC,CAAA;AAEzB,qEAAqE;AAErE,oEAAoE;AACpE,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,SAAS,EAAE,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG;IACtC,SAAS,EAAE,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG;CAC9B,CAAA;AAEV,iEAAiE;AACjE,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG;CACrB,CAAA;AAEV;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAe;IACrC,UAAU,EAAE,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG;IACtC,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG;IACpC,UAAU,EAAE,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG;CAC9B,CAAA;AAEV;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAwB,IAAI,GAAG,CAAS;IACvE,IAAI;IACJ,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC;IAClC,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC;CAChC,CAAC,CAAA"}

package/dist/path-dsl.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Path DSL + kernel-navigation registration.
+ *
+ *  1. **Tagged-template shortcuts** for building typed Path instances.
+ *     Each alias delegates to the corresponding `.parse()` — same
+ *     validation, same perf, same narrowing semantics.
+ *
+ *     Tagged-template form (supports interpolation):
+ *       abs`/${origin}/foo/bar`       → AbsolutePath
+ *       rel`./foo/bar`                → RelativePath
+ *       dom`/:messaging:Message`      → DomainPath
+ *       mth`/:messaging:M:send`       → MethodPath
+ *       cls`/:messaging:class.X`      → ClassPath
+ *       iface`/:messaging:interface.X`→ InterfacePath
+ *       fn`@${nodeId}::send`          → InstanceMethodPath
+ *       p`/${whatever}`               → Path (auto-narrowed at runtime)
+ *
+ *     String form (wire-boundary callsites):
+ *       abs(rawFromWire)
+ *
+ *  2. **Single-entry registration.** {@link registerKernelLanguage}(K)
+ *     arms the global GrammarRegistry / SchemeRegistry / PathTypeRegistry
+ *     with everything kernel-meta consumers need. Called by `kernel.ts`
+ *     once `K` is compiled. No auto-fire on module load — boot order is
+ *     explicit. Typed-path factories (`ClassPath.from`, etc.) lex
+ *     against an internal grammar closure, so compile-time path
+ *     construction does NOT depend on the global registry.
+ */
+import type { CompiledDomain } from '#domain/compile/types';
+import type { TreePath } from './graph/tree';
+import { ClassPath, DomainPath, InstanceMethodPath, InterfacePath, MethodPath } from './domain/addressing/paths';
+import { IdPath, Path } from './graph/nav/path';
+import { AbsolutePath, RelativePath } from './graph/tree';
+/**
+ * Arm the global path registries with the kernel-meta navigation:
+ * grammar tokens, scheme segments, and PathTypes every kernel-protocol
+ * consumer needs to parse / detect paths.
+ *
+ * Single entry point — call once at kernel boot, after
+ * `compileDomain(KernelSchema)`. Idempotent on identity-equal entries
+ * (the registries dedupe), so repeat calls are safe.
+ *
+ * Order matters for ambiguous detection cases: registries scan
+ * last-registered-first, so more-specific entries register *after*
+ * more-general ones. Universal PathTypes (Absolute / Relative / Id /
+ * InstanceMethod) come before the four kernel-meta types
+ * (Domain / Class / Interface / Method) so the latter win on ties.
+ */
+export declare function registerKernelLanguage(kernel: CompiledDomain): void;
+type DSLInput = string | TemplateStringsArray;
+export declare const tree: (s: DSLInput, ...v: unknown[]) => TreePath;
+export declare const abs: (s: DSLInput, ...v: unknown[]) => AbsolutePath;
+export declare const rel: (s: DSLInput, ...v: unknown[]) => RelativePath;
+export declare const dom: (s: DSLInput, ...v: unknown[]) => DomainPath;
+export declare const mth: (s: DSLInput, ...v: unknown[]) => MethodPath;
+export declare const cls: (s: DSLInput, ...v: unknown[]) => ClassPath;
+export declare const iface: (s: DSLInput, ...v: unknown[]) => InterfacePath;
+export declare const fn: (s: DSLInput, ...v: unknown[]) => InstanceMethodPath;
+export declare const id: (s: DSLInput, ...v: unknown[]) => IdPath;
+export declare const p: (s: DSLInput, ...v: unknown[]) => Path;
+export {};
+//# sourceMappingURL=path-dsl.d.ts.map

package/dist/path-dsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-dsl.d.ts","sourceRoot":"","sources":["../path-dsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAE3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAI5C,OAAO,EACL,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,aAAa,EACb,UAAU,EACX,MAAM,2BAA2B,CAAA;AAUlC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAoB,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AASzD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAsBnE;AAID,KAAK,QAAQ,GAAG,MAAM,GAAG,oBAAoB,CAAA;AAM7C,eAAO,MAAM,IAAI,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,QAA2C,CAAA;AAE/F,eAAO,MAAM,GAAG,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,YAA+C,CAAA;AAElG,eAAO,MAAM,GAAG,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,YAA+C,CAAA;AAElG,eAAO,MAAM,GAAG,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,UAA2C,CAAA;AAE9F,eAAO,MAAM,GAAG,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,UAA2C,CAAA;AAE9F,eAAO,MAAM,GAAG,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,SAAyC,CAAA;AAE5F,eAAO,MAAM,KAAK,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,aACnB,CAAA;AAElC,eAAO,MAAM,EAAE,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,kBACX,CAAA;AAEvC,eAAO,MAAM,EAAE,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,MAAmC,CAAA;AAErF,eAAO,MAAM,CAAC,MAAO,QAAQ,QAAQ,OAAO,EAAE,KAAG,IAA+B,CAAA"}

package/dist/path-dsl.js

@@ -0,0 +1,100 @@
+/**
+ * Path DSL + kernel-navigation registration.
+ *
+ *  1. **Tagged-template shortcuts** for building typed Path instances.
+ *     Each alias delegates to the corresponding `.parse()` — same
+ *     validation, same perf, same narrowing semantics.
+ *
+ *     Tagged-template form (supports interpolation):
+ *       abs`/${origin}/foo/bar`       → AbsolutePath
+ *       rel`./foo/bar`                → RelativePath
+ *       dom`/:messaging:Message`      → DomainPath
+ *       mth`/:messaging:M:send`       → MethodPath
+ *       cls`/:messaging:class.X`      → ClassPath
+ *       iface`/:messaging:interface.X`→ InterfacePath
+ *       fn`@${nodeId}::send`          → InstanceMethodPath
+ *       p`/${whatever}`               → Path (auto-narrowed at runtime)
+ *
+ *     String form (wire-boundary callsites):
+ *       abs(rawFromWire)
+ *
+ *  2. **Single-entry registration.** {@link registerKernelLanguage}(K)
+ *     arms the global GrammarRegistry / SchemeRegistry / PathTypeRegistry
+ *     with everything kernel-meta consumers need. Called by `kernel.ts`
+ *     once `K` is compiled. No auto-fire on module load — boot order is
+ *     explicit. Typed-path factories (`ClassPath.from`, etc.) lex
+ *     against an internal grammar closure, so compile-time path
+ *     construction does NOT depend on the global registry.
+ */
+import { domainGrammar } from './domain/addressing/grammar/domain';
+import { instanceMethodGrammar } from './domain/addressing/grammar/instance-method';
+import { ClassPath, DomainPath, InstanceMethodPath, InterfacePath, MethodPath, } from './domain/addressing/paths';
+import { makeClassPathType } from './domain/addressing/paths/class';
+import { makeDomainPathType } from './domain/addressing/paths/domain';
+import { instanceMethodPathType } from './domain/addressing/paths/instance-method';
+import { makeInterfacePathType } from './domain/addressing/paths/interface';
+import { makeMethodPathType } from './domain/addressing/paths/method';
+import { installedInSegment } from './domain/addressing/segments/installed-in';
+import { methodOfSegment } from './domain/addressing/segments/method-of';
+import { ofDomainSegment } from './domain/addressing/segments/of-domain';
+import { GrammarRegistry } from './graph/nav/grammar';
+import { IdPath, Path, PathTypeRegistry } from './graph/nav/path';
+import { idPathType } from './graph/nav/path/kinds/id-path';
+import { SchemeRegistry } from './graph/nav/scheme';
+import { AbsolutePath, RelativePath } from './graph/tree';
+import { absoluteGrammar } from './graph/tree/path/absolute/grammar';
+import { absoluteSegment } from './graph/tree/path/absolute/segment';
+import { absolutePathType } from './graph/tree/path/absolute/type';
+import { relativeGrammar } from './graph/tree/path/relative/grammar';
+import { relativePathType } from './graph/tree/path/relative/type';
+// ── Registration ─────────────────────────────────────────────────────
+/**
+ * Arm the global path registries with the kernel-meta navigation:
+ * grammar tokens, scheme segments, and PathTypes every kernel-protocol
+ * consumer needs to parse / detect paths.
+ *
+ * Single entry point — call once at kernel boot, after
+ * `compileDomain(KernelSchema)`. Idempotent on identity-equal entries
+ * (the registries dedupe), so repeat calls are safe.
+ *
+ * Order matters for ambiguous detection cases: registries scan
+ * last-registered-first, so more-specific entries register *after*
+ * more-general ones. Universal PathTypes (Absolute / Relative / Id /
+ * InstanceMethod) come before the four kernel-meta types
+ * (Domain / Class / Interface / Method) so the latter win on ties.
+ */
+export function registerKernelLanguage(kernel) {
+    // Grammars (lexer extensions).
+    GrammarRegistry.register(absoluteGrammar);
+    GrammarRegistry.register(relativeGrammar);
+    GrammarRegistry.register(domainGrammar);
+    GrammarRegistry.register(instanceMethodGrammar);
+    // Scheme segments (graph-walking recipes referenced by typed PathTypes).
+    SchemeRegistry.register(absoluteSegment);
+    SchemeRegistry.register(installedInSegment);
+    SchemeRegistry.register(ofDomainSegment);
+    SchemeRegistry.register(methodOfSegment);
+    // PathTypes — universal first, kernel-meta (bound to `d`) last.
+    PathTypeRegistry.register(absolutePathType);
+    PathTypeRegistry.register(relativePathType);
+    PathTypeRegistry.register(idPathType);
+    PathTypeRegistry.register(instanceMethodPathType);
+    PathTypeRegistry.register(makeDomainPathType(kernel));
+    PathTypeRegistry.register(makeClassPathType(kernel));
+    PathTypeRegistry.register(makeInterfacePathType(kernel));
+    PathTypeRegistry.register(makeMethodPathType(kernel));
+}
+function toRaw(s, values) {
+    return typeof s === 'string' ? s : String.raw(s, ...values);
+}
+export const tree = (s, ...v) => AbsolutePath.parse(toRaw(s, v));
+export const abs = (s, ...v) => AbsolutePath.parse(toRaw(s, v));
+export const rel = (s, ...v) => RelativePath.parse(toRaw(s, v));
+export const dom = (s, ...v) => DomainPath.parse(toRaw(s, v));
+export const mth = (s, ...v) => MethodPath.parse(toRaw(s, v));
+export const cls = (s, ...v) => ClassPath.parse(toRaw(s, v));
+export const iface = (s, ...v) => InterfacePath.parse(toRaw(s, v));
+export const fn = (s, ...v) => InstanceMethodPath.parse(toRaw(s, v));
+export const id = (s, ...v) => IdPath.parse(toRaw(s, v));
+export const p = (s, ...v) => Path.parse(toRaw(s, v));
+//# sourceMappingURL=path-dsl.js.map

package/dist/path-dsl.js.map

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

package/dist/schema/classes/Class.class.d.ts

@@ -0,0 +1,279 @@
+import z from 'zod';
+export declare const Class: import("@astrale-os/kernel-dsl").NodeClassDef<Omit<{
+    readonly implements: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+        readonly methods: {
+            listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly filters: z.ZodOptional<z.ZodUnknown>;
+            }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+            push: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            }, z.ZodVoid, "sealed", boolean>;
+        };
+    }, "props"> & {
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    onConflict: z.ZodOptional<z.ZodEnum<{
+                        defaults: "defaults";
+                        error: "error";
+                        merge: "merge";
+                        replace: "replace";
+                        skip: "skip";
+                    }>>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    name: z.ZodString;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    description: z.ZodOptional<z.ZodString>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    status: z.ZodEnum<{
+                        active: "active";
+                        creating: "creating";
+                        deleting: "deleting";
+                        error: "error";
+                        updating: "updating";
+                    }>;
+                };
+            }>];
+            readonly methods: {
+                init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                update: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.ZodVoid, "default", boolean>;
+                delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                move: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                }, z.ZodVoid, "sealed", boolean>;
+                link: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodVoid, "default", boolean>;
+                unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                }, z.ZodVoid, "default", boolean>;
+                getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                    readonly direction: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        in: "in";
+                        out: "out";
+                    }>>;
+                }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly depth: z.ZodNumber;
+                    readonly maxNodes: z.ZodNumber;
+                }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+            };
+        }>];
+    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+        readonly properties: {
+            icon: z.ZodOptional<z.ZodString>;
+        };
+    }>];
+    readonly icon: string;
+    readonly methods: {
+        init: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly name: z.ZodString;
+            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+            readonly description: z.ZodOptional<z.ZodString>;
+            readonly domain: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+        }, z.ZodVoid, import("@astrale-os/kernel-dsl").MethodInheritance, true>;
+    };
+}, "props"> & {
+    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                onConflict: z.ZodOptional<z.ZodEnum<{
+                    defaults: "defaults";
+                    error: "error";
+                    merge: "merge";
+                    replace: "replace";
+                    skip: "skip";
+                }>>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                name: z.ZodString;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                description: z.ZodOptional<z.ZodString>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                status: z.ZodEnum<{
+                    active: "active";
+                    creating: "creating";
+                    deleting: "deleting";
+                    error: "error";
+                    updating: "updating";
+                }>;
+            };
+        }>];
+        readonly methods: {
+            init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+            createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+            get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+            update: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.ZodVoid, "default", boolean>;
+            delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+            deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+            move: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+            }, z.ZodVoid, "sealed", boolean>;
+            link: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.ZodVoid, "default", boolean>;
+            unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+            }, z.ZodVoid, "default", boolean>;
+            getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                readonly direction: z.ZodOptional<z.ZodEnum<{
+                    both: "both";
+                    in: "in";
+                    out: "out";
+                }>>;
+            }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+            getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly depth: z.ZodNumber;
+                readonly maxNodes: z.ZodNumber;
+            }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+        };
+    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+        readonly methods: {
+            listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly filters: z.ZodOptional<z.ZodUnknown>;
+            }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+            push: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            }, z.ZodVoid, "sealed", boolean>;
+        };
+    }, "props"> & {
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    onConflict: z.ZodOptional<z.ZodEnum<{
+                        defaults: "defaults";
+                        error: "error";
+                        merge: "merge";
+                        replace: "replace";
+                        skip: "skip";
+                    }>>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    name: z.ZodString;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    description: z.ZodOptional<z.ZodString>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    status: z.ZodEnum<{
+                        active: "active";
+                        creating: "creating";
+                        deleting: "deleting";
+                        error: "error";
+                        updating: "updating";
+                    }>;
+                };
+            }>];
+            readonly methods: {
+                init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                update: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.ZodVoid, "default", boolean>;
+                delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                move: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                }, z.ZodVoid, "sealed", boolean>;
+                link: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodVoid, "default", boolean>;
+                unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                }, z.ZodVoid, "default", boolean>;
+                getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                    readonly direction: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        in: "in";
+                        out: "out";
+                    }>>;
+                }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly depth: z.ZodNumber;
+                    readonly maxNodes: z.ZodNumber;
+                }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+            };
+        }>];
+    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+        readonly properties: {
+            icon: z.ZodOptional<z.ZodString>;
+        };
+    }>];
+}>;
+//# sourceMappingURL=Class.class.d.ts.map

package/dist/schema/classes/Class.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Class.class.d.ts","sourceRoot":"","sources":["../../../schema/classes/Class.class.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AASnB,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAId,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWN,CAAA"}

package/dist/schema/classes/Class.class.js

@@ -0,0 +1,24 @@
+import { fn } from '@astrale-os/kernel-dsl';
+import z from 'zod';
+import { pathSchema } from '#graph/nav/path/zod';
+import { absolutePathSchema } from '#graph/tree/zod';
+import { nodeClass } from '#schema/definitions';
+import { Container, Iconable } from '#schema/interfaces';
+import { CLASS_ICON } from './icons';
+export const Class = nodeClass({
+    implements: [Container, Iconable],
+    icon: CLASS_ICON,
+    methods: {
+        init: fn({
+            static: true,
+            params: {
+                name: z.string().min(1).max(100),
+                path: absolutePathSchema(),
+                description: z.string().optional(),
+                domain: pathSchema(),
+            },
+            returns: z.void(),
+        }),
+    },
+});
+//# sourceMappingURL=Class.class.js.map

package/dist/schema/classes/Class.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Class.class.js","sourceRoot":"","sources":["../../../schema/classes/Class.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAA;AAC3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAExD,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEpC,MAAM,CAAC,MAAM,KAAK,GAAG,SAAS,CAAC;IAC7B,UAAU,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC;IACjC,IAAI,EAAE,UAAU;IAChB,OAAO,EAAE;QACP,IAAI,EAAE,EAAE,CAAC;YACP,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE;gBACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;gBAChC,IAAI,EAAE,kBAAkB,EAAE;gBAC1B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;gBAClC,MAAM,EAAE,UAAU,EAAE;aACrB;YACD,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;KACH;CACF,CAAC,CAAA"}