@astrale-os/kernel-core 0.4.1

package/dist/schema/interfaces/Function.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Function.interface.d.ts","sourceRoot":"","sources":["../../../schema/interfaces/Function.interface.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAIjB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASN,CAAA"}

package/dist/schema/interfaces/Function.interface.js

@@ -0,0 +1,28 @@
+import { fn } from '@astrale-os/kernel-dsl';
+import { z } from 'zod';
+import { functionSchema } from '#domain/compile/method/serialized';
+import { nodeInterface } from '#schema/definitions';
+import { Container } from './Container.interface';
+import { Identity } from './Identity.interface';
+/**
+ * Graph node schema for Function (Method / View / RemoteFunction) nodes.
+ *
+ * Props derive from `functionSchema` (defined in #domain) — single source of
+ * truth. The graph stores these as flat stringified key/values; conversion
+ * happens in `materialize/serialize.ts`.
+ */
+export const Function = nodeInterface({
+    extends: [Container, Identity],
+    props: functionSchema.shape,
+    methods: {
+        list: fn({
+            static: true,
+            inheritance: 'default',
+            params: {
+                methodsOnly: z.boolean().optional(),
+            },
+            returns: z.array(functionSchema),
+        }),
+    },
+});
+//# sourceMappingURL=Function.interface.js.map

package/dist/schema/interfaces/Function.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Function.interface.js","sourceRoot":"","sources":["../../../schema/interfaces/Function.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAA;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAEnD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC;IACpC,OAAO,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC9B,KAAK,EAAE,cAAc,CAAC,KAAK;IAC3B,OAAO,EAAE;QACP,IAAI,EAAE,EAAE,CAAC;YACP,MAAM,EAAE,IAAI;YACZ,WAAW,EAAE,SAAS;YACtB,MAAM,EAAE;gBACN,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;aACpC;YACD,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC;SACjC,CAAC;KACH;CACF,CAAC,CAAA"}

package/dist/schema/interfaces/Identity.interface.d.ts

@@ -0,0 +1,183 @@
+import { z } from 'zod';
+import type { Node as GraphNode } from '#graph';
+export declare const Identity: import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+    readonly props: {
+        iss: z.ZodString;
+        sub: z.ZodString;
+        frozen: z.ZodOptional<z.ZodBoolean>;
+        publicKey: z.ZodOptional<z.ZodObject<{
+            jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+            jwksUri: z.ZodOptional<z.ZodURL>;
+        }, z.core.$strip>>;
+        requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            claim: z.ZodString;
+            op: z.ZodLiteral<"eq">;
+            value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            claim: z.ZodString;
+            op: z.ZodLiteral<"contains">;
+            value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            claim: z.ZodString;
+            op: z.ZodLiteral<"exists">;
+        }, z.core.$strip>], "op">>>;
+    };
+    readonly methods: {
+        extendIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly with: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+        }, z.ZodVoid, "sealed", boolean>;
+        constrainIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly by: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+        }, z.ZodVoid, "sealed", boolean>;
+        excludeIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly without: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+        }, z.ZodVoid, "sealed", boolean>;
+        removeExtension: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+        }, z.ZodVoid, "sealed", boolean>;
+        removeConstraint: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+        }, z.ZodVoid, "sealed", boolean>;
+        removeExclusion: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+        }, z.ZodVoid, "sealed", boolean>;
+        grantPerm: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            readonly perms: z.ZodNumber;
+        }, z.ZodVoid, "sealed", boolean>;
+        revokePerm: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            readonly perms: z.ZodNumber;
+        }, z.ZodVoid, "sealed", boolean>;
+        checkPerm: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            readonly perms: z.ZodNumber;
+        }, z.ZodBoolean, "sealed", boolean>;
+        registerIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly signingKey: z.ZodOptional<z.ZodObject<{
+                publicKey: z.ZodObject<{
+                    jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                    jwksUri: z.ZodOptional<z.ZodURL>;
+                }, z.core.$strip>;
+                credential: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.ZodObject<{
+            iss: z.ZodString;
+            sub: z.ZodString;
+        }, z.core.$strip>, "sealed", boolean>;
+        mintIdentityCredential: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodString, "sealed", boolean>;
+        mintDelegationCredential: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly audience: z.ZodOptional<z.ZodString>;
+            readonly delegation: z.ZodCustom<import("#auth/expression").UnresolvedIdentityExpr, import("#auth/expression").UnresolvedIdentityExpr>;
+            readonly attestation: z.ZodOptional<z.ZodCustom<import("#auth/expression").SelfIdentityExpr, import("#auth/expression").SelfIdentityExpr>>;
+            readonly ttl: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodString, "sealed", boolean>;
+        findIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly issuer: z.ZodString;
+            readonly subject: z.ZodString;
+        }, z.ZodNullable<z.ZodCustom<GraphNode, GraphNode>>, "sealed", true>;
+        whoami: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodCustom<GraphNode, GraphNode>, "sealed", true>;
+    };
+}, "props"> & {
+    readonly properties: {
+        iss: z.ZodString;
+        sub: z.ZodString;
+        frozen: z.ZodOptional<z.ZodBoolean>;
+        publicKey: z.ZodOptional<z.ZodObject<{
+            jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+            jwksUri: z.ZodOptional<z.ZodURL>;
+        }, z.core.$strip>>;
+        requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            claim: z.ZodString;
+            op: z.ZodLiteral<"eq">;
+            value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            claim: z.ZodString;
+            op: z.ZodLiteral<"contains">;
+            value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            claim: z.ZodString;
+            op: z.ZodLiteral<"exists">;
+        }, z.core.$strip>], "op">>>;
+    };
+} & {
+    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("#graph").ExternalId, import("#graph").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<GraphNode, GraphNode>, "sealed", true>;
+            get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<GraphNode, GraphNode>, "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("#graph").Edge[], import("#graph").Edge[]>, "sealed", boolean>;
+            getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly depth: z.ZodNumber;
+                readonly maxNodes: z.ZodNumber;
+            }, z.ZodCustom<import("#graph").GraphData, import("#graph").GraphData>, "sealed", boolean>;
+        };
+    }>];
+}>;
+//# sourceMappingURL=Identity.interface.d.ts.map

package/dist/schema/interfaces/Identity.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Identity.interface.d.ts","sourceRoot":"","sources":["../../../schema/interfaces/Identity.interface.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,QAAQ,CAAA;AAQ/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;QAGjB,cAAc;;;QAKd,iBAAiB;;;QAKjB,eAAe;;;QAKf,eAAe;;;QAKf,gBAAgB;;;QAKhB,eAAe;;;QAKf,SAAS;;;;QAKT,UAAU;;;;QAKV,SAAS;;;;QAKT,gBAAgB;;;;;;;;;;;;QAehB,sBAAsB;QAKtB,wBAAwB;;;;;;QAUxB,YAAY;;;;QASZ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOR,CAAA"}

package/dist/schema/interfaces/Identity.interface.js

@@ -0,0 +1,103 @@
+import { fn } from '@astrale-os/kernel-dsl';
+import { z } from 'zod';
+import { unresolvedIdentityExprSchema, selfIdentityExprSchema } from '#auth/expression';
+import { identityPropsSchema } from '#auth/identity/types';
+import { publicKeySchema } from '#auth/jwks/types';
+import { pathSchema } from '#graph/nav/path/zod';
+import { nodeInterface } from '#schema/definitions';
+export const Identity = nodeInterface({
+    props: identityPropsSchema.shape,
+    methods: {
+        extendIdentity: fn({
+            inheritance: 'sealed',
+            params: { with: pathSchema() },
+            returns: z.void(),
+        }),
+        constrainIdentity: fn({
+            inheritance: 'sealed',
+            params: { by: pathSchema() },
+            returns: z.void(),
+        }),
+        excludeIdentity: fn({
+            inheritance: 'sealed',
+            params: { without: pathSchema() },
+            returns: z.void(),
+        }),
+        removeExtension: fn({
+            inheritance: 'sealed',
+            params: { identity: pathSchema() },
+            returns: z.void(),
+        }),
+        removeConstraint: fn({
+            inheritance: 'sealed',
+            params: { identity: pathSchema() },
+            returns: z.void(),
+        }),
+        removeExclusion: fn({
+            inheritance: 'sealed',
+            params: { identity: pathSchema() },
+            returns: z.void(),
+        }),
+        grantPerm: fn({
+            inheritance: 'sealed',
+            params: { node: pathSchema(), perms: z.number().int() },
+            returns: z.void(),
+        }),
+        revokePerm: fn({
+            inheritance: 'sealed',
+            params: { node: pathSchema(), perms: z.number().int() },
+            returns: z.void(),
+        }),
+        checkPerm: fn({
+            inheritance: 'sealed',
+            params: { node: pathSchema(), perms: z.number().int() },
+            returns: z.boolean(),
+        }),
+        registerIdentity: fn({
+            inheritance: 'sealed',
+            params: {
+                signingKey: z
+                    .object({
+                    publicKey: publicKeySchema,
+                    credential: z.string(),
+                })
+                    .optional(),
+            },
+            returns: z.object({
+                iss: z.string(),
+                sub: z.string(),
+            }),
+        }),
+        mintIdentityCredential: fn({
+            inheritance: 'sealed',
+            params: {},
+            returns: z.string(),
+        }),
+        mintDelegationCredential: fn({
+            inheritance: 'sealed',
+            params: {
+                audience: z.string().optional(),
+                delegation: unresolvedIdentityExprSchema,
+                attestation: selfIdentityExprSchema.optional(),
+                ttl: z.number().int().positive().optional(),
+            },
+            returns: z.string(),
+        }),
+        findIdentity: fn({
+            inheritance: 'sealed',
+            static: true,
+            params: {
+                issuer: z.string(),
+                subject: z.string(),
+            },
+            returns: z.custom().nullable(),
+        }),
+        whoami: fn({
+            inheritance: 'sealed',
+            static: true,
+            params: {},
+            returns: z.custom(),
+        }),
+    },
+});
+//# sourceMappingURL=Identity.interface.js.map

package/dist/schema/interfaces/Identity.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Identity.interface.js","sourceRoot":"","sources":["../../../schema/interfaces/Identity.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAA;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,OAAO,EAAE,4BAA4B,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAA;AACvF,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAEnD,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC;IACpC,KAAK,EAAE,mBAAmB,CAAC,KAAK;IAChC,OAAO,EAAE;QACP,cAAc,EAAE,EAAE,CAAC;YACjB,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE;YAC9B,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;QACF,iBAAiB,EAAE,EAAE,CAAC;YACpB,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE;YAC5B,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;QACF,eAAe,EAAE,EAAE,CAAC;YAClB,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE;YACjC,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;QACF,eAAe,EAAE,EAAE,CAAC;YAClB,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE;YAClC,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;QACF,gBAAgB,EAAE,EAAE,CAAC;YACnB,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE;YAClC,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;QACF,eAAe,EAAE,EAAE,CAAC;YAClB,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE;YAClC,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;QACF,SAAS,EAAE,EAAE,CAAC;YACZ,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;YACvD,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;QACF,UAAU,EAAE,EAAE,CAAC;YACb,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;YACvD,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;QACF,SAAS,EAAE,EAAE,CAAC;YACZ,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;YACvD,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;SACrB,CAAC;QACF,gBAAgB,EAAE,EAAE,CAAC;YACnB,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE;gBACN,UAAU,EAAE,CAAC;qBACV,MAAM,CAAC;oBACN,SAAS,EAAE,eAAe;oBAC1B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;iBACvB,CAAC;qBACD,QAAQ,EAAE;aACd;YACD,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC;gBAChB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;gBACf,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;aAChB,CAAC;SACH,CAAC;QACF,sBAAsB,EAAE,EAAE,CAAC;YACzB,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,EAAE;YACV,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;SACpB,CAAC;QACF,wBAAwB,EAAE,EAAE,CAAC;YAC3B,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE;gBACN,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;gBAC/B,UAAU,EAAE,4BAA4B;gBACxC,WAAW,EAAE,sBAAsB,CAAC,QAAQ,EAAE;gBAC9C,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;aAC5C;YACD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;SACpB,CAAC;QACF,YAAY,EAAE,EAAE,CAAC;YACf,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE;gBACN,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;gBAClB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;aACpB;YACD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAa,CAAC,QAAQ,EAAE;SAC1C,CAAC;QACF,MAAM,EAAE,EAAE,CAAC;YACT,WAAW,EAAE,QAAQ;YACrB,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,EAAE;YACV,OAAO,EAAE,CAAC,CAAC,MAAM,EAAa;SAC/B,CAAC;KACH;CACF,CAAC,CAAA"}

package/dist/schema/interfaces/Node.interface.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import type { Edge, Node as GraphNode, GraphData } from '#graph';
+export declare const Node: 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("#graph").ExternalId, import("#graph").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<GraphNode, GraphNode>, "sealed", true>;
+        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<GraphNode, GraphNode>, "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("#graph/nav/ast/slug").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("#graph/nav/ast/slug").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<Edge[], Edge[]>, "sealed", boolean>;
+        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly depth: z.ZodNumber;
+            readonly maxNodes: z.ZodNumber;
+        }, z.ZodCustom<GraphData, GraphData>, "sealed", boolean>;
+    };
+}>;
+//# sourceMappingURL=Node.interface.d.ts.map

package/dist/schema/interfaces/Node.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Node.interface.d.ts","sourceRoot":"","sources":["../../../schema/interfaces/Node.interface.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,IAAI,SAAS,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAShE,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAGb,IAAI;QACJ,UAAU;;;;;QAUV,GAAG;QACH,MAAM;;;QAKN,MAAM;QACN,UAAU;QACV,IAAI;;;QAKJ,IAAI;;;;;;QAUJ,MAAM;;;;;QASN,QAAQ;;;;;;;;QAQR,OAAO;;;;;EAST,CAAA"}

package/dist/schema/interfaces/Node.interface.js

@@ -0,0 +1,72 @@
+import { nodeInterface, fn } from '@astrale-os/kernel-dsl';
+import { z } from 'zod';
+import { classPathSchema } from '#domain/addressing/paths/zod';
+import { slugSchema } from '#graph/nav/ast/slug';
+import { pathSchema } from '#graph/nav/path/zod';
+import { absolutePathSchema } from '#graph/tree/zod';
+import { Statused, Named, Descriptable, Remotable, Timestamped } from './generics';
+export const Node = nodeInterface({
+    inherits: [Timestamped, Remotable, Named, Descriptable, Statused],
+    methods: {
+        init: fn({ inheritance: 'default', static: true, returns: z.void() }),
+        createNode: fn({
+            inheritance: 'sealed',
+            static: true,
+            params: {
+                class: classPathSchema(),
+                path: absolutePathSchema(),
+                props: z.record(z.string(), z.unknown()).optional(),
+            },
+            returns: z.custom(),
+        }),
+        get: fn({ inheritance: 'sealed', returns: z.custom() }),
+        update: fn({
+            inheritance: 'default',
+            params: { props: z.record(z.string(), z.unknown()) },
+            returns: z.void(),
+        }),
+        delete: fn({ inheritance: 'default', returns: z.void() }),
+        deleteNode: fn({ inheritance: 'sealed', returns: z.null() }),
+        move: fn({
+            inheritance: 'sealed',
+            params: { to: absolutePathSchema() },
+            returns: z.void(),
+        }),
+        link: fn({
+            inheritance: 'default',
+            params: {
+                edgeClass: classPathSchema(),
+                target: pathSchema(),
+                slug: slugSchema.optional(),
+                props: z.record(z.string(), z.unknown()).optional(),
+            },
+            returns: z.void(),
+        }),
+        unlink: fn({
+            inheritance: 'default',
+            params: {
+                edgeClass: classPathSchema(),
+                target: pathSchema(),
+                slug: slugSchema.optional(),
+            },
+            returns: z.void(),
+        }),
+        getLinks: fn({
+            inheritance: 'sealed',
+            params: {
+                edgeClasses: z.array(classPathSchema()).optional(),
+                direction: z.enum(['in', 'out', 'both']).optional(),
+            },
+            returns: z.custom(),
+        }),
+        getTree: fn({
+            inheritance: 'sealed',
+            params: {
+                depth: z.number(),
+                maxNodes: z.number(),
+            },
+            returns: z.custom(),
+        }),
+    },
+});
+//# sourceMappingURL=Node.interface.js.map

package/dist/schema/interfaces/Node.interface.js.map

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