@astrale-os/kernel-core 0.9.0-beta.9 → 1.0.0-beta.2

package/dist/auth/provision/request/request.d.ts

@@ -1,29 +0,0 @@
-import type { LocalBinding, MutationAST } from '../../../graph/mutate/index.js';
-import type { ClaimConstraint } from '../../claims/index.js';
-import type { CredentialInput } from '../../credential/input/index.js';
-import type { Subject } from '../../identity/index.js';
-import type { IssuerId } from '../../issuer/index.js';
-import type { JsonWebKey } from '../../jwk/index.js';
-export type RequiredClaims = readonly ClaimConstraint[];
-export interface AssertedIdentityProvision {
-    readonly issuer: IssuerId;
-    readonly subject: Subject;
-    readonly requiredClaims?: RequiredClaims;
-    readonly credentials?: never;
-}
-export interface SelfIdentityProvision {
-    readonly credentials: {
-        readonly publicKey: JsonWebKey;
-        readonly proof: CredentialInput;
-    };
-    readonly requiredClaims?: RequiredClaims;
-    readonly issuer?: never;
-    readonly subject?: never;
-}
-export type IdentityProvisionInput = AssertedIdentityProvision | SelfIdentityProvision;
-/** One conditional graph transition whose Identity births are explicitly designated by binding. */
-export interface ProvisionRequest {
-    readonly idempotencyKey: string;
-    readonly mutation: MutationAST;
-    readonly identities: Readonly<Record<LocalBinding, IdentityProvisionInput>>;
-}

package/dist/auth/provision/result/index.d.ts

@@ -1 +0,0 @@
-export type { ProvisionedIdentity, ProvisionResult } from './result.js';

package/dist/auth/provision/result/result.d.ts

@@ -1,12 +0,0 @@
-import type { LocalBinding } from '../../../graph/mutate/index.js';
-import type { NodeId } from '../../../graph/node/index.js';
-import type { Subject } from '../../identity/index.js';
-import type { IssuerId } from '../../issuer/index.js';
-export interface ProvisionedIdentity {
-    readonly issuer: IssuerId;
-    readonly subject: Subject;
-}
-export interface ProvisionResult {
-    readonly createdNodes: Readonly<Record<LocalBinding, NodeId>>;
-    readonly identities: Readonly<Record<LocalBinding, ProvisionedIdentity>>;
-}

package/dist/graph/graph/navigation/error.d.ts

@@ -1,12 +0,0 @@
-import type { NodePath } from '../../path/index.js';
-export declare class GraphPathAmbiguousError extends Error {
-    readonly path: NodePath;
-    readonly matches: number;
-    readonly code: 'GRAPH_PATH_AMBIGUOUS';
-    constructor(path: NodePath, matches: number);
-}
-export declare class GraphPathWalkerRequiredError extends Error {
-    readonly path: NodePath;
-    readonly code: 'GRAPH_PATH_WALKER_REQUIRED';
-    constructor(path: NodePath);
-}

package/dist/graph/graph/navigation/error.js

@@ -1,20 +0,0 @@
-export class GraphPathAmbiguousError extends Error {
-    path;
-    matches;
-    code = 'GRAPH_PATH_AMBIGUOUS';
-    constructor(path, matches) {
-        super(`Graph Path ${JSON.stringify(path)} matched ${matches} distinct Nodes.`);
-        this.path = path;
-        this.matches = matches;
-        this.name = 'GraphPathAmbiguousError';
-    }
-}
-export class GraphPathWalkerRequiredError extends Error {
-    path;
-    code = 'GRAPH_PATH_WALKER_REQUIRED';
-    constructor(path) {
-        super(`Graph Path ${JSON.stringify(path)} requires a walker.`);
-        this.path = path;
-        this.name = 'GraphPathWalkerRequiredError';
-    }
-}

package/dist/graph/graph/navigation/index.d.ts

@@ -1,2 +0,0 @@
-export type { GraphPathContext, GraphPathWalker } from './model.js';
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './error.js';

package/dist/graph/graph/navigation/index.js

@@ -1 +0,0 @@
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './error.js';

package/dist/graph/graph/navigation/model.d.ts

@@ -1,15 +0,0 @@
-import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import type { EdgeOrientation } from '@astrale-os/kernel-dsl/v1/language';
-import type { Node } from '../../node/index.js';
-import type { Path } from '../../path/index.js';
-import type { GraphEdges, GraphNodes } from '../indexes/index.js';
-/** Semantic read-only graph capabilities available to a Path walker. */
-export interface GraphPathContext {
-    readonly nodes: GraphNodes;
-    readonly edges: GraphEdges;
-    orientation(classKey: ClassKey): EdgeOrientation | undefined;
-}
-/** Pure injected semantics for walking one Path against an admitted Graph. */
-export interface GraphPathWalker {
-    walk(path: Path, context: GraphPathContext): Node | undefined;
-}

package/dist/schema/callables/view-for.d.ts

@@ -1,296 +0,0 @@
-import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const ViewFor: builder.DirectedEdgeClass<{
-    readonly abstract: false;
-    readonly source: {
-        readonly as: "view";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "The installed projection of a declarative browser surface; it is not a principal.";
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                readonly properties: {
-                    description: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 1000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>];
-            readonly methods: Readonly<{
-                resolve: builder.Method<{
-                    readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
-                    readonly auth: "authorized";
-                    readonly input: import("zod").ZodObject<{
-                        target: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: import("zod").ZodObject<{
-                        snapshot: import("zod").ZodString;
-                        views: import("zod").ZodArray<import("zod").ZodObject<{
-                            key: import("zod").ZodString;
-                            declaration: import("zod").ZodObject<{
-                                description: import("zod").ZodOptional<import("zod").ZodString>;
-                                target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                    kind: import("zod").ZodLiteral<"domain">;
-                                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                    kind: import("zod").ZodLiteral<"definition">;
-                                    definitions: import("zod").ZodArray<import("zod").ZodObject<{
-                                        origin: import("zod").ZodString;
-                                        kind: import("zod").ZodLiteral<"class">;
-                                        name: import("zod").ZodString;
-                                    }, import("zod/v4/core").$strict>>;
-                                }, import("zod/v4/core").$strict>], "kind">;
-                            }, import("zod/v4/core").$strict>;
-                            href: import("zod").ZodString;
-                            handshake: import("zod").ZodEnum<{
-                                none: "none";
-                                shell: "shell";
-                            }>;
-                            issuer: import("zod").ZodString;
-                            etag: import("zod").ZodString;
-                            revision: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly static: true;
-                    readonly inheritance: "sealed";
-                }>;
-            }>;
-        }>];
-        readonly outgoing: "1..*";
-    };
-    readonly target: {
-        readonly as: "target";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "The installed graph projection of a Node Class or Edge Class declaration.";
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                readonly properties: {
-                    description: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 1000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>, builder.NodeClass<{
-                readonly abstract: true;
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly description: "Optional bounded presentation icon metadata.";
-                readonly properties: {
-                    icon: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 8000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>];
-            readonly properties: {
-                readonly kind: {
-                    readonly enum: readonly ["node", "edge"];
-                };
-                readonly abstract: {
-                    readonly type: "boolean";
-                };
-            };
-        }>, builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "A stable Domain principal and the active projection of one canonical DomainSchema revision.";
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly properties: {
-                    readonly frozen: builder.Property<{
-                        readonly type: "boolean";
-                    }, {
-                        readonly required: false;
-                        readonly visibility: "private";
-                    }>;
-                    readonly iss: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly requiredClaims: builder.Property<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"contains">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"eq">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"exists">;
-                    }, import("zod/v4/core").$strict>], "op">>, {
-                        readonly required: false;
-                        readonly visibility: "private";
-                    }>;
-                    readonly sub: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                };
-                readonly methods: Readonly<{
-                    delegate: builder.Method<{
-                        readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{
-                            audience: import("zod").ZodString;
-                            ttlSeconds: import("zod").ZodNumber;
-                            attenuation: import("zod").ZodUnknown;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodString;
-                        readonly inheritance: "default";
-                    }>;
-                    can: builder.Method<{
-                        readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{
-                            policy: import("zod").ZodString;
-                            object: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodObject<{
-                            allowed: import("zod").ZodBoolean;
-                        }, import("zod/v4/core").$strict>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    whoami: builder.Method<{
-                        readonly description: "Return the Identity authenticated for this invocation.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodObject<{
-                            id: import("zod").ZodString;
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                            frozen: import("zod").ZodBoolean;
-                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"contains">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"eq">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"exists">;
-                            }, import("zod/v4/core").$strict>], "op">>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    whois: builder.Method<{
-                        readonly description: "Resolve one issuer-and-subject Identity.";
-                        readonly auth: "authorized";
-                        readonly input: import("zod").ZodObject<{
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodNullable<import("zod").ZodObject<{
-                            id: import("zod").ZodString;
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                            frozen: import("zod").ZodBoolean;
-                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"contains">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"eq">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"exists">;
-                            }, import("zod/v4/core").$strict>], "op">>;
-                        }, import("zod/v4/core").$strict>>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    mint: builder.Method<{
-                        readonly description: "Resolve and sign one authorized Grant credential.";
-                        readonly auth: "authorized";
-                        readonly input: import("zod").ZodObject<{
-                            audience: import("zod").ZodOptional<import("zod").ZodString>;
-                            ttlSeconds: import("zod").ZodNumber;
-                            grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodString;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                }>;
-            }>];
-            readonly properties: {
-                readonly origin: {
-                    readonly type: "string";
-                    readonly pattern: "[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+";
-                };
-                readonly dependencyContext: builder.Property<{
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                    };
-                }, {
-                    readonly visibility: "private";
-                    readonly required: false;
-                }>;
-                readonly schema: builder.Property<{
-                    readonly type: "object";
-                }, {
-                    readonly visibility: "private";
-                }>;
-                readonly schemaRevision: builder.Property<{
-                    readonly type: "string";
-                    readonly pattern: "sha256:[0-9a-f]{64}";
-                }, {
-                    readonly visibility: "private";
-                }>;
-            };
-        }>];
-        readonly incoming: "0..*";
-    };
-    readonly description: "A View declaration targets one Domain or a non-empty set of Classes.";
-    readonly extends: readonly [builder.DirectedEdgeClass<{
-        readonly abstract: true;
-        readonly source: {
-            readonly as: "source";
-            readonly accepts: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly outgoing: "0..*";
-        };
-        readonly target: {
-            readonly as: "target";
-            readonly accepts: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly incoming: "0..*";
-        };
-        readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
-    }>];
-}>;

package/dist/schema/callables/view-for.js

@@ -1,12 +0,0 @@
-import { edgeClass } from '@astrale-os/kernel-dsl/v1';
-import { Class } from '../definitions/index.js';
-import { Domain } from '../domain/index.js';
-import { Edge } from '../meta/index.js';
-import { View } from './view.js';
-export const ViewFor = edgeClass.directed({
-    abstract: false,
-    source: { as: 'view', accepts: [View], outgoing: '1..*' },
-    target: { as: 'target', accepts: [Class, Domain], incoming: '0..*' },
-    description: 'A View declaration targets one Domain or a non-empty set of Classes.',
-    extends: [Edge],
-});

package/dist/schema/kernel/projection/keys.d.ts

@@ -1,3 +0,0 @@
-import type { Domain } from '@astrale-os/kernel-dsl/v1';
-export declare function managedKeys(domain: Domain): readonly string[];
-export declare function coreKeys(domain: Domain): readonly string[];

package/dist/schema/kernel/projection/path.d.ts

@@ -1,2 +0,0 @@
-import type { GraphPathWalker } from '#graph/graph';
-export declare const projectionPathWalker: GraphPathWalker;

package/dist/schema/kernel/projection/path.js

@@ -1,140 +0,0 @@
-import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import { GraphPathAmbiguousError } from '#graph/graph';
-import { K } from '../index.js';
-export const projectionPathWalker = Object.freeze({
-    walk: walkProjectionPath,
-});
-function walkProjectionPath(path, context) {
-    let candidates = anchorCandidates(path.ast, context);
-    for (const step of path.ast.steps)
-        candidates = applyStep(candidates, step, context);
-    if (candidates.length === 0)
-        return undefined;
-    if (candidates.length === 1)
-        return candidates[0];
-    throw new GraphPathAmbiguousError(path.raw, candidates.length);
-}
-function anchorCandidates(ast, context) {
-    if (ast.anchor.kind === 'id') {
-        const node = context.nodes.byId(ast.anchor.id);
-        return node === undefined ? [] : [node];
-    }
-    const domainClass = ClassKey.of(K.classes.Domain.ref);
-    const origin = ast.anchor.origin;
-    return context.nodes
-        .byClass(domainClass)
-        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === origin);
-}
-function applyStep(current, step, context) {
-    switch (step.kind) {
-        case 'projection':
-            return domainMembers(current, `${step.projection.kind}.${step.projection.name}`, context);
-        case 'method':
-            return step.dispatch === 'static'
-                ? directMethods(current, step.name, true, context)
-                : instanceMethods(current, step.name, context);
-        case 'traverse':
-            return traverse(current, step, context);
-    }
-}
-function domainMembers(domains, member, context) {
-    const domainIds = new Set(domains.map((node) => node.id));
-    return distinctNodes(edgesOf(K.classes.of_domain, context).flatMap((edge) => {
-        if (!domainIds.has(edge.target) ||
-            edge.props[K.classes.of_domain.properties.member.key] !== member) {
-            return [];
-        }
-        const node = context.nodes.byId(edge.source);
-        return node === undefined ? [] : [node];
-    }));
-}
-function directMethods(owners, name, isStatic, context) {
-    const ownerIds = new Set(owners.map((node) => node.id));
-    return distinctNodes(edgesOf(K.classes.method_of, context).flatMap((edge) => {
-        if (!ownerIds.has(edge.target) ||
-            edge.props[K.classes.method_of.properties.name.key] !== name ||
-            edge.props[K.classes.method_of.properties.static.key] !== isStatic) {
-            return [];
-        }
-        const method = context.nodes.byId(edge.source);
-        return method === undefined ? [] : [method];
-    }));
-}
-function instanceMethods(instances, name, context) {
-    return distinctNodes(instances.flatMap((instance) => {
-        const owner = resolveClassProjection(instance.class, context);
-        return owner.length === 0 ? [] : effectiveMethods(owner, name, context);
-    }));
-}
-function resolveClassProjection(key, context) {
-    const domainClass = ClassKey.of(K.classes.Domain.ref);
-    const domains = context.nodes
-        .byClass(domainClass)
-        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === ClassKey.ref(key).origin);
-    return domainMembers(domains, `class.${ClassKey.ref(key).name}`, context);
-}
-/** Select the nearest declared Method in the valid Definition inheritance graph. */
-function effectiveMethods(roots, name, context) {
-    let level = distinctNodes(roots);
-    const visited = new Set();
-    while (level.length > 0) {
-        const fresh = level.filter((node) => !visited.has(node.id));
-        for (const node of fresh)
-            visited.add(node.id);
-        if (fresh.length === 0)
-            return [];
-        const methods = directMethods(fresh, name, false, context);
-        if (methods.length > 0)
-            return methods;
-        level = parentDefinitions(fresh, context);
-    }
-    return [];
-}
-function parentDefinitions(definitions, context) {
-    const ids = new Set(definitions.map((node) => node.id));
-    const relations = [K.classes.extends];
-    return distinctNodes(relations.flatMap((relation) => edgesOf(relation, context).flatMap((edge) => {
-        if (!ids.has(edge.source))
-            return [];
-        const parent = context.nodes.byId(edge.target);
-        return parent === undefined ? [] : [parent];
-    })));
-}
-function traverse(current, step, context) {
-    const currentIds = new Set(current.map((node) => node.id));
-    const edgeClass = step.class;
-    const orientation = context.orientation(edgeClass);
-    const candidates = context.edges.byClass(edgeClass);
-    return distinctNodes(candidates.flatMap((edge) => {
-        if (step.slug !== undefined && edge.slug !== step.slug)
-            return [];
-        const endpoint = traversedEndpoint(edge, currentIds, step.direction, orientation);
-        if (endpoint === undefined)
-            return [];
-        const node = context.nodes.byId(endpoint);
-        return node === undefined ? [] : [node];
-    }));
-}
-function traversedEndpoint(edge, current, direction, orientation) {
-    if (orientation === 'undirected') {
-        if (current.has(edge.source))
-            return edge.target;
-        if (current.has(edge.target))
-            return edge.source;
-        return undefined;
-    }
-    if (direction === 'out' && current.has(edge.source))
-        return edge.target;
-    if (direction === 'in' && current.has(edge.target))
-        return edge.source;
-    return undefined;
-}
-function edgesOf(relation, context) {
-    return context.edges.byClass(ClassKey.of(relation.ref));
-}
-function distinctNodes(nodes) {
-    const byId = new Map();
-    for (const node of nodes)
-        byId.set(node.id, node);
-    return [...byId.values()];
-}