@astrale-os/kernel-core 0.9.0-beta.8 → 1.0.0-beta.1

package/dist/schema/authority/governed-by.d.ts

@@ -1,110 +1,34 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const GovernedBy: builder.DirectedEdgeClass<{
+    readonly depth: 1;
     readonly abstract: false;
-    readonly source: {
-        readonly as: "class";
-        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";
-                };
-            };
-        }>];
-        readonly outgoing: "0..*";
-    };
-    readonly target: {
-        readonly as: "policy";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "The installed graph projection of one named closed Policy declaration owned by a Domain.";
-            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 incoming: "0..*";
-    };
-    readonly description: "The protected projection of one Class read or traverse Policy assignment.";
-    readonly extends: readonly [builder.DirectedEdgeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"edge", {
         readonly abstract: true;
+        readonly depth: 0;
+        readonly properties: never;
         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.";
-    }>];
+        readonly constraints: Record<never, never>;
+    }, never, never, never>];
     readonly properties: {
-        operations: builder.Property<{
-            readonly enum: readonly [readonly ["read"], readonly ["traverse"], readonly ["read", "traverse"]];
-        }, {
-            readonly visibility: "private";
-        }>;
+        readonly operations: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "operations", "self", never>;
+    };
+    readonly source: {
+        readonly as: "class";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "policy";
+        readonly incoming: "0..*";
     };
     readonly constraints: {
         readonly noSelf: true;
     };
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "operations", "self", never>;
 }>;
-//# sourceMappingURL=governed-by.d.ts.map

package/dist/schema/authority/governed-by.js

@@ -9,8 +9,7 @@ export const GovernedBy = edgeClass.directed({
     description: 'The protected projection of one Class read or traverse Policy assignment.',
     extends: [Edge],
     properties: {
-        operations: property({ enum: [['read'], ['traverse'], ['read', 'traverse']] }, { visibility: 'private' }),
+        operations: property({ enum: [['read'], ['traverse'], ['read', 'traverse']] }, {}),
     },
     constraints: { noSelf: true },
 });
-//# sourceMappingURL=governed-by.js.map

package/dist/schema/authority/index.d.ts

@@ -12,4 +12,3 @@ export { Operation } from './operation-node.js';
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from './operations.js';
 export type { AuthorityOperation, AuthorityRelation } from './operations.js';
 export { Policy } from './policy.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/authority/index.js

@@ -11,4 +11,3 @@ export { GovernedBy } from './governed-by.js';
 export { Operation } from './operation-node.js';
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from './operations.js';
 export { Policy } from './policy.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/authority/operation-node.d.ts

@@ -1,21 +1,34 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Operation: builder.NodeClass<{
+    readonly depth: 2;
     readonly abstract: false;
-    readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         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: "Stable human-facing name metadata that never acts as a locator.";
+        readonly depth: 1;
         readonly properties: {
-            readonly name: {
-                readonly type: "string";
-                readonly minLength: 1;
-                readonly maxLength: 100;
-            };
+            readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
         };
-    }>];
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", unknown, undefined>, never, never>, undefined>, never, never>];
+    readonly properties: never;
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", unknown, undefined>, never, never>, undefined>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=operation-node.d.ts.map

package/dist/schema/authority/operation-node.js

@@ -5,4 +5,3 @@ export const Operation = nodeClass({
     description: 'One closed authority relation operation administered by can_grant and can_revoke.',
     extends: [Named],
 });
-//# sourceMappingURL=operation-node.js.map

package/dist/schema/authority/operation.d.ts

@@ -1,3 +1,2 @@
 export declare const AuthorityOperationOrder: readonly ["create", "read", "update", "delete", "traverse", "use", "grant", "revoke"];
 export type AuthorityOperation = (typeof AuthorityOperationOrder)[number];
-//# sourceMappingURL=operation.d.ts.map

package/dist/schema/authority/operation.js

@@ -8,4 +8,3 @@ export const AuthorityOperationOrder = Object.freeze([
     'grant',
     'revoke',
 ]);
-//# sourceMappingURL=operation.js.map

package/dist/schema/authority/operations.d.ts

@@ -10,175 +10,14 @@ import { CanUse } from './can-use.js';
 import { AuthorityOperationOrder, type AuthorityOperation } from './operation.js';
 export { AuthorityOperationOrder, type AuthorityOperation };
 export declare const AuthorityOperations: Readonly<{
-    create: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        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: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "create";
-    }>;
-    read: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        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: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "read";
-    }>;
-    update: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        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: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "update";
-    }>;
-    delete: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        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: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "delete";
-    }>;
-    traverse: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        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: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "traverse";
-    }>;
-    use: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        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: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "use";
-    }>;
-    grant: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        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: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "grant";
-    }>;
-    revoke: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        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: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "revoke";
-    }>;
+    create: builder.CoreNode;
+    read: builder.CoreNode;
+    update: builder.CoreNode;
+    delete: builder.CoreNode;
+    traverse: builder.CoreNode;
+    use: builder.CoreNode;
+    grant: builder.CoreNode;
+    revoke: builder.CoreNode;
 }>;
 export type AuthorityRelation = typeof CanCreate | typeof CanRead | typeof CanUpdate | typeof CanDelete | typeof CanTraverse | typeof CanUse | typeof CanGrant | typeof CanRevoke;
 export declare function operationOf(relation: AuthorityRelation): AuthorityOperation;
-//# sourceMappingURL=operations.d.ts.map

package/dist/schema/authority/operations.js

@@ -36,4 +36,3 @@ export function operationOf(relation) {
         return 'grant';
     return 'revoke';
 }
-//# sourceMappingURL=operations.js.map

package/dist/schema/authority/policy.d.ts

@@ -1,23 +1,34 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Policy: builder.NodeClass<{
+    readonly depth: 2;
     readonly abstract: false;
-    readonly description: "The installed graph projection of one named closed Policy declaration owned by a Domain.";
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         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 depth: 1;
         readonly properties: {
-            description: builder.Property<Readonly<{
-                readonly type: 'string';
-                readonly minLength: 1;
-                readonly maxLength: 1000;
-            }>, {
-                readonly required: false;
-            }>;
+            readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
         };
-    }>];
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>, never, never>];
+    readonly properties: never;
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=policy.d.ts.map

package/dist/schema/authority/policy.js

@@ -5,4 +5,3 @@ export const Policy = nodeClass({
     description: 'The installed graph projection of one named closed Policy declaration owned by a Domain.',
     extends: [Descriptable],
 });
-//# sourceMappingURL=policy.js.map

package/dist/schema/authority/vocabulary.d.ts

@@ -0,0 +1,3 @@
+import type { authority } from '../../auth/index.js';
+/** The Kernel instance of the authority vocabulary; Core Auth interprets authority through it. */
+export declare const authorityVocabulary: authority.AuthorityVocabulary;

package/dist/schema/authority/vocabulary.js

@@ -0,0 +1,25 @@
+import { K } from '../kernel/schema.js';
+/** The Kernel instance of the authority vocabulary; Core Auth interprets authority through it. */
+export const authorityVocabulary = Object.freeze({
+    identity: ref(K.classes.Identity.ref),
+    composition: Object.freeze({
+        extension: ref(K.classes.extends_with.ref),
+        constraint: ref(K.classes.constrained_by.ref),
+        exclusion: ref(K.classes.excluded_from.ref),
+    }),
+    capabilities: Object.freeze({
+        create: ref(K.classes.can_create.ref),
+        read: ref(K.classes.can_read.ref),
+        traverse: ref(K.classes.can_traverse.ref),
+        update: ref(K.classes.can_update.ref),
+        delete: ref(K.classes.can_delete.ref),
+    }),
+    instanceOf: ref(K.classes.instance_of.ref),
+});
+function ref(value) {
+    return Object.freeze({
+        origin: value.origin,
+        kind: 'class',
+        name: value.name,
+    });
+}

package/dist/schema/callables/entrypoint.d.ts

@@ -0,0 +1,32 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Entrypoint: builder.DirectedEdgeClass<{
+    readonly depth: 1;
+    readonly abstract: false;
+    readonly extends: readonly [builder.ClassReferenceProjection<"edge", {
+        readonly abstract: true;
+        readonly depth: 0;
+        readonly properties: never;
+        readonly source: {
+            readonly as: "source";
+            readonly outgoing: "0..*";
+        };
+        readonly target: {
+            readonly as: "target";
+            readonly incoming: "0..*";
+        };
+        readonly constraints: Record<never, never>;
+    }, never, never, never>];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "view";
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "domain";
+        readonly incoming: "0..1";
+    };
+    readonly constraints: {
+        readonly noSelf: true;
+    };
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/callables/entrypoint.js

@@ -0,0 +1,12 @@
+import { edgeClass } from '@astrale-os/kernel-dsl/v1';
+import { Domain } from '../domain/index.js';
+import { Edge } from '../meta/index.js';
+import { View } from './view.js';
+export const Entrypoint = edgeClass.directed({
+    abstract: false,
+    source: { as: 'view', accepts: [View], outgoing: '0..1' },
+    target: { as: 'domain', accepts: [Domain], incoming: '0..1' },
+    description: 'The one View a Domain opens by default; a Domain declares at most one.',
+    extends: [Edge],
+    constraints: { noSelf: true },
+});