@astrale-os/kernel-protocol 0.5.0-beta.9 → 0.5.0

package/dist/publication/publication.js

@@ -1,133 +0,0 @@
-import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
-import { accept as acceptIssuerId } from '@astrale-os/kernel-core/auth/issuer';
-import { Key, patterns } from '@astrale-os/kernel-dsl/v1/addressing';
-import * as portable from '@astrale-os/kernel-dsl/value';
-import { admitCallableBinding, admitViewBinding } from './bindings/index.js';
-import { array, deepFreeze, exact, record, unique } from './content.js';
-import { admitEndpoint as admitDeliveryEndpoint } from './delivery-endpoint.js';
-import { fail } from './error.js';
-import { admitDigest, computeEtag } from './etag.js';
-import { admitManifest } from './manifest.js';
-import { admitRequirements } from './requirements.js';
-import { admitRoute } from './route.js';
-import { admitSchema } from './schema.js';
-export const PATH = '/.well-known/astrale/domain.json';
-export const MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=2';
-/** Resolve the canonical Publication URL beneath one exact HTTP(S) serving issuer. */
-export function url(input) {
-    const admitted = admitIssuer(input);
-    let value;
-    try {
-        value = new URL(admitted);
-    }
-    catch (cause) {
-        return fail('PUBLICATION_INVALID', 'Publication issuer is not an HTTP(S) URL.', cause);
-    }
-    if ((value.protocol !== 'https:' && value.protocol !== 'http:') ||
-        value.username !== '' ||
-        value.password !== '' ||
-        value.search !== '' ||
-        value.hash !== '') {
-        fail('PUBLICATION_INVALID', 'Publication issuer is not an HTTP(S) URL.');
-    }
-    return `${admitted.replace(/\/+$/u, '')}${PATH}`;
-}
-export function seal(input) {
-    return acceptPublication({ ...input, etag: computeEtag(input) }, false);
-}
-export function accept(input) {
-    const publication = acceptPublication(input, true);
-    if (publication.etag !== computeEtag(withoutEtag(publication))) {
-        fail('PUBLICATION_ETAG_MISMATCH', 'Publication ETag does not match its canonical content.');
-    }
-    return publication;
-}
-export function encode(input) {
-    return portable.json.encode(input);
-}
-function acceptPublication(input, requireEtag) {
-    const value = record(input, 'PUBLICATION_INVALID', 'Expected a Publication object.');
-    exact(value, [
-        'format',
-        'version',
-        'origin',
-        'identity',
-        'etag',
-        'schema',
-        'requirements',
-        'manifest',
-        'bindings',
-        'routes',
-        'delivery',
-    ], 'PUBLICATION_INVALID');
-    if (value.format !== 'astrale.domain.publication' || value.version !== 2) {
-        fail('PUBLICATION_INVALID', 'Unsupported Publication format or version.');
-    }
-    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
-        fail('PUBLICATION_INVALID', 'Publication origin is invalid.');
-    }
-    const origin = value.origin;
-    const identity = record(value.identity, 'PUBLICATION_INVALID', 'Publication identity is invalid.');
-    exact(identity, ['issuer', 'subject'], 'PUBLICATION_INVALID');
-    const issuer = admitIssuer(identity.issuer);
-    if (identity.subject !== origin) {
-        fail('PUBLICATION_INVALID', 'Publication identity subject must equal its root origin.');
-    }
-    const publishedSchema = admitSchema(value.schema);
-    const requirements = admitRequirements(value.requirements);
-    const manifest = admitManifest(value.manifest);
-    const bindingSet = record(value.bindings, 'PUBLICATION_BINDING_INVALID', 'Publication bindings are invalid.');
-    exact(bindingSet, ['callables', 'views'], 'PUBLICATION_BINDING_INVALID');
-    const callables = array(bindingSet.callables, 'PUBLICATION_BINDING_INVALID').map((entry) => admitCallableBinding(entry, origin));
-    unique(callables.map(({ callable }) => callable), 'PUBLICATION_BINDING_INVALID', 'callable binding');
-    const views = array(bindingSet.views, 'PUBLICATION_VIEW_INVALID').map((entry) => admitViewBinding(entry, origin));
-    unique(views.map(({ view }) => view), 'PUBLICATION_VIEW_INVALID', 'View binding');
-    const routes = array(value.routes, 'PUBLICATION_ROUTE_INVALID').map((entry) => admitRoute(entry, origin));
-    unique(routes.map(({ name }) => name), 'PUBLICATION_ROUTE_INVALID', 'route name');
-    for (const callable of new Set(routes.map(({ callable }) => callable))) {
-        if (routes.filter((route) => route.callable === callable && route.default === true).length > 1) {
-            fail('PUBLICATION_ROUTE_INVALID', `Callable ${callable} has more than one default route.`);
-        }
-    }
-    if (manifest?.entrypoint !== undefined) {
-        if (manifest.entrypoint.origin !== origin) {
-            fail('PUBLICATION_VIEW_INVALID', 'Manifest entrypoint must belong to the root origin.');
-        }
-        const key = Key.of(manifest.entrypoint);
-        if (!views.some(({ view }) => view === key)) {
-            fail('PUBLICATION_VIEW_INVALID', 'Manifest entrypoint must have a published View binding.');
-        }
-    }
-    const delivery = admitDeliveryEndpoint(value.delivery, publishedSchema.bundle.href);
-    const admittedEtag = requireEtag ? admitDigest(value.etag) : value.etag;
-    if (typeof admittedEtag !== 'string')
-        fail('PUBLICATION_INVALID', 'Publication ETag is missing.');
-    return deepFreeze({
-        format: 'astrale.domain.publication',
-        version: 2,
-        origin,
-        identity: { issuer, subject: origin },
-        etag: admittedEtag,
-        schema: publishedSchema,
-        requirements,
-        ...(manifest === undefined ? {} : { manifest }),
-        bindings: { callables, views },
-        routes,
-        ...(delivery === undefined ? {} : { delivery }),
-    });
-}
-function admitIssuer(input) {
-    try {
-        return acceptIssuerId(String(input));
-    }
-    catch (cause) {
-        if (cause instanceof AuthValueError) {
-            return fail('PUBLICATION_INVALID', 'Publication issuer is invalid.', cause);
-        }
-        throw cause;
-    }
-}
-function withoutEtag(input) {
-    const { etag: _etag, ...content } = input;
-    return content;
-}

package/dist/publication/reference.d.ts

@@ -1,17 +0,0 @@
-import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
-import { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
-import type { Etag } from './etag.js';
-import type { Publication } from './publication.js';
-/** Compact untrusted projection that witnesses one exact Publication. */
-export interface PublicationRef {
-    readonly origin: Key.Origin;
-    readonly identity: Publication['identity'];
-    readonly revision: Revision;
-    readonly etag: Etag;
-}
-export type PublicationReferenceRelation = 'exact' | 'same-schema' | 'schema-drift' | 'identity-drift' | 'origin-drift';
-export declare function reference(input: Publication): PublicationRef;
-export declare function acceptReference(input: unknown): PublicationRef;
-export declare function compareReferences(input: PublicationRef, expected: PublicationRef): PublicationReferenceRelation;
-export declare function compareReference(input: Publication, expected: PublicationRef): PublicationReferenceRelation;
-export declare function matchesReference(input: Publication, expected: PublicationRef): boolean;

package/dist/publication/reference.js

@@ -1,68 +0,0 @@
-import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
-import { accept as acceptIssuerId } from '@astrale-os/kernel-core/auth/issuer';
-import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
-import { deepFreeze, exact, record } from './content.js';
-import { fail } from './error.js';
-import { admitDigest } from './etag.js';
-export function reference(input) {
-    return deepFreeze({
-        origin: input.origin,
-        identity: { ...input.identity },
-        revision: input.schema.revision,
-        etag: input.etag,
-    });
-}
-export function acceptReference(input) {
-    const value = record(input, 'PUBLICATION_INVALID', 'Publication reference is invalid.');
-    exact(value, ['origin', 'identity', 'revision', 'etag'], 'PUBLICATION_INVALID');
-    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
-        fail('PUBLICATION_INVALID', 'Publication reference origin is invalid.');
-    }
-    const origin = value.origin;
-    const identity = record(value.identity, 'PUBLICATION_INVALID', 'Publication reference identity is invalid.');
-    exact(identity, ['issuer', 'subject'], 'PUBLICATION_INVALID');
-    const issuer = acceptIssuer(identity.issuer);
-    if (identity.subject !== origin) {
-        fail('PUBLICATION_INVALID', 'Publication reference subject must equal its root origin.');
-    }
-    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
-        fail('PUBLICATION_INVALID', 'Publication reference revision is invalid.');
-    }
-    return deepFreeze({
-        origin,
-        identity: { issuer, subject: origin },
-        revision: value.revision,
-        etag: admitDigest(value.etag),
-    });
-}
-export function compareReferences(input, expected) {
-    if (input.origin !== expected.origin)
-        return 'origin-drift';
-    if (input.identity.issuer !== expected.identity.issuer ||
-        input.identity.subject !== expected.identity.subject) {
-        return 'identity-drift';
-    }
-    if (input.revision !== expected.revision)
-        return 'schema-drift';
-    return input.etag === expected.etag ? 'exact' : 'same-schema';
-}
-export function compareReference(input, expected) {
-    return compareReferences(reference(input), expected);
-}
-export function matchesReference(input, expected) {
-    return compareReference(input, expected) === 'exact';
-}
-function acceptIssuer(input) {
-    if (typeof input !== 'string') {
-        fail('PUBLICATION_INVALID', 'Publication reference issuer is invalid.');
-    }
-    try {
-        return acceptIssuerId(input);
-    }
-    catch (cause) {
-        if (cause instanceof AuthValueError) {
-            return fail('PUBLICATION_INVALID', 'Publication reference issuer is invalid.', cause);
-        }
-        throw cause;
-    }
-}

package/dist/publication/requirements.d.ts

@@ -1,26 +0,0 @@
-import type { AuthorityOperation } from '@astrale-os/kernel-core/schema/authority/operation';
-import type { schema } from '@astrale-os/kernel-dsl/v1';
-import type { ClassRef, Key as SemanticKey } from '@astrale-os/kernel-dsl/v1/addressing';
-export type NonEmpty<Value> = readonly [Value, ...Value[]];
-export declare const ClassOperationOrder: readonly ["create", "read", "traverse", "update", "delete"];
-export type ClassOperation = (typeof ClassOperationOrder)[number];
-export interface ClassCapabilityRequirement {
-    readonly class: ClassRef;
-    readonly operations: NonEmpty<ClassOperation>;
-}
-export interface CapabilityAdminRequirements {
-    readonly grant?: NonEmpty<AuthorityOperation>;
-    readonly revoke?: NonEmpty<AuthorityOperation>;
-}
-export interface CapabilityRequirements {
-    readonly functions?: NonEmpty<SemanticKey.Callable>;
-    readonly classes?: NonEmpty<ClassCapabilityRequirement>;
-    readonly admin?: CapabilityAdminRequirements;
-}
-export interface PublicationRequirements {
-    readonly capabilities: CapabilityRequirements;
-}
-/** Admit the exact closed Publication v2 requirements object. */
-export declare function admitRequirements(input: unknown): PublicationRequirements;
-/** Bind explicit capability targets to exact functional dependencies in the bundle closure. */
-export declare function validateRequirements(root: schema.DomainSchema, closure: readonly schema.DomainSchema[], requirements: PublicationRequirements): void;

package/dist/publication/requirements.js

@@ -1,180 +0,0 @@
-import { AuthorityOperationOrder } from '@astrale-os/kernel-core/schema/authority/operation';
-import { acceptDefinitionRef, callableAddress, Key } from '@astrale-os/kernel-dsl/v1/addressing';
-import { revision } from '@astrale-os/kernel-dsl/v1/schema/revision';
-import { array, deepFreeze, exact, record, unique } from './content.js';
-import { fail } from './error.js';
-export const ClassOperationOrder = Object.freeze([
-    'create',
-    'read',
-    'traverse',
-    'update',
-    'delete',
-]);
-/** Admit the exact closed Publication v2 requirements object. */
-export function admitRequirements(input) {
-    const requirements = record(input, 'PUBLICATION_INVALID', 'Publication requirements are invalid.');
-    exact(requirements, ['capabilities'], 'PUBLICATION_INVALID');
-    const capabilities = record(requirements.capabilities, 'PUBLICATION_INVALID', 'Publication capability requirements are invalid.');
-    exact(capabilities, ['admin', 'classes', 'functions'], 'PUBLICATION_INVALID');
-    const functions = capabilities.functions === undefined
-        ? undefined
-        : nonEmpty(capabilities.functions, 'Function capability requirements').map(admitCallable);
-    if (functions !== undefined) {
-        unique(functions, 'PUBLICATION_INVALID', 'Function capability requirement');
-        canonical(functions, compare, 'Function capability requirements');
-    }
-    const classes = capabilities.classes === undefined
-        ? undefined
-        : nonEmpty(capabilities.classes, 'Class capability requirements').map(admitClassRequirement);
-    if (classes !== undefined) {
-        unique(classes.map((entry) => classKey(entry.class)), 'PUBLICATION_INVALID', 'Class capability requirement');
-        canonical(classes, (left, right) => compare(classKey(left.class), classKey(right.class)), 'Class capability requirements');
-    }
-    const admin = capabilities.admin === undefined ? undefined : admitAdminRequirements(capabilities.admin);
-    return deepFreeze({
-        capabilities: {
-            ...(functions === undefined
-                ? {}
-                : { functions: Object.freeze(functions) }),
-            ...(classes === undefined
-                ? {}
-                : { classes: Object.freeze(classes) }),
-            ...(admin === undefined ? {} : { admin }),
-        },
-    });
-}
-/** Bind explicit capability targets to exact functional dependencies in the bundle closure. */
-export function validateRequirements(root, closure, requirements) {
-    const dependencies = exactDependencyClosure(root, closure);
-    for (const callable of requirements.capabilities.functions ?? []) {
-        const dependency = capabilityOwner(root, dependencies, callable, 'Function');
-        if (!hasCallable(dependency, callable)) {
-            fail('PUBLICATION_INVALID', 'Function capability requirement names an unknown dependency callable.');
-        }
-    }
-    for (const requirement of requirements.capabilities.classes ?? []) {
-        const key = Key.of(requirement.class);
-        const dependency = capabilityOwner(root, dependencies, key, 'Class');
-        if (dependency.classes[requirement.class.name] === undefined) {
-            fail('PUBLICATION_INVALID', 'Class capability requirement names an unknown dependency Class.');
-        }
-    }
-}
-function exactDependencyClosure(root, closure) {
-    const supplied = new Map(closure.map((dependency) => [dependency.origin, dependency]));
-    const reachable = new Map();
-    const visit = (owner) => {
-        for (const coordinate of owner.dependencies) {
-            const dependency = supplied.get(coordinate.origin);
-            if (dependency === undefined || revision(dependency) !== coordinate.revision) {
-                fail('PUBLICATION_INVALID', 'Publication Bundle omits an exact dependency.');
-            }
-            if (reachable.has(dependency.origin))
-                continue;
-            reachable.set(dependency.origin, dependency);
-            visit(dependency);
-        }
-    };
-    visit(root);
-    return reachable;
-}
-function admitCallable(input) {
-    if (typeof input !== 'string' || !Key.is(input)) {
-        return fail('PUBLICATION_INVALID', 'Function capability reference is invalid.');
-    }
-    try {
-        callableAddress(input);
-    }
-    catch {
-        return fail('PUBLICATION_INVALID', 'Function capability reference must name a Function or Method.');
-    }
-    return input;
-}
-function admitClassRequirement(input) {
-    const requirement = record(input, 'PUBLICATION_INVALID', 'Class capability requirement is invalid.');
-    exact(requirement, ['class', 'operations'], 'PUBLICATION_INVALID');
-    const operations = nonEmpty(requirement.operations, 'Class capability operations').map((entry) => admitOperation(entry, ClassOperationOrder, 'Class capability operation'));
-    unique(operations, 'PUBLICATION_INVALID', 'Class capability operation');
-    canonical(operations, ordered(ClassOperationOrder), 'Class capability operations');
-    return Object.freeze({
-        class: admitClassRef(requirement.class),
-        operations: Object.freeze(operations),
-    });
-}
-function admitAdminRequirements(input) {
-    const admin = record(input, 'PUBLICATION_INVALID', 'Administrative capability requirements are invalid.');
-    exact(admin, ['grant', 'revoke'], 'PUBLICATION_INVALID');
-    if (admin.grant === undefined && admin.revoke === undefined) {
-        fail('PUBLICATION_INVALID', 'Administrative capability requirements cannot be empty.');
-    }
-    const grant = admitAuthorityOperations(admin.grant, 'grant');
-    const revoke = admitAuthorityOperations(admin.revoke, 'revoke');
-    return Object.freeze({
-        ...(grant === undefined ? {} : { grant }),
-        ...(revoke === undefined ? {} : { revoke }),
-    });
-}
-function admitAuthorityOperations(input, kind) {
-    if (input === undefined)
-        return undefined;
-    const values = nonEmpty(input, `Administrative ${kind} operations`).map((entry) => admitOperation(entry, AuthorityOperationOrder, `Administrative ${kind} operation`));
-    unique(values, 'PUBLICATION_INVALID', `administrative ${kind} operation`);
-    canonical(values, ordered(AuthorityOperationOrder), `Administrative ${kind} operations`);
-    return Object.freeze(values);
-}
-function admitClassRef(input) {
-    let value;
-    try {
-        value = acceptDefinitionRef(input);
-    }
-    catch {
-        fail('PUBLICATION_INVALID', 'Class capability reference is invalid.');
-    }
-    if (value.kind !== 'class')
-        fail('PUBLICATION_INVALID', 'Class capability reference is invalid.');
-    return value;
-}
-function nonEmpty(input, label) {
-    const values = [...array(input, 'PUBLICATION_INVALID')];
-    if (values.length === 0)
-        fail('PUBLICATION_INVALID', `${label} cannot be empty.`);
-    return values;
-}
-function admitOperation(input, vocabulary, label) {
-    if (typeof input !== 'string' || !vocabulary.includes(input)) {
-        return fail('PUBLICATION_INVALID', `${label} is unknown.`);
-    }
-    return input;
-}
-function canonical(values, comparator, label) {
-    if (values.some((entry, index) => index > 0 && comparator(values[index - 1], entry) >= 0)) {
-        fail('PUBLICATION_INVALID', `${label} must be sorted canonically.`);
-    }
-}
-function ordered(order) {
-    return (left, right) => order.indexOf(left) - order.indexOf(right);
-}
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function classKey(input) {
-    return String(Key.of(input));
-}
-function capabilityOwner(root, dependencies, key, label) {
-    const origin = Key.origin(key);
-    if (origin === root.origin)
-        fail('PUBLICATION_INVALID', `${label} capability target cannot be local.`);
-    const dependency = dependencies.get(origin);
-    if (dependency === undefined) {
-        fail('PUBLICATION_INVALID', `${label} capability target must belong to the exact dependency closure.`);
-    }
-    return dependency;
-}
-function hasCallable(dependency, callable) {
-    const coordinate = callableAddress(callable);
-    if (coordinate.kind === 'function')
-        return dependency.functions[coordinate.name] !== undefined;
-    const declaration = dependency.classes[coordinate.owner.name];
-    const method = declaration?.kind === 'node' ? declaration.methods[coordinate.name] : undefined;
-    return method !== undefined && method.inheritance !== 'abstract';
-}

package/dist/routes/release-unavailable.d.ts

@@ -1,8 +0,0 @@
-import type { HttpRequest } from './request.js';
-export interface ReleaseUnavailable {
-    readonly kind: 'release-unavailable';
-}
-export declare const HTTP_ROUTE_RELEASE_UNAVAILABLE: 'x-astrale-release-unavailable';
-export declare const HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS: 410;
-export declare function releaseUnavailableHeaders(): Readonly<Record<string, string>>;
-export declare function decodeReleaseUnavailable(status: number, headers: HttpRequest['headers']): ReleaseUnavailable | undefined;

package/dist/routes/release-unavailable.js

@@ -1,32 +0,0 @@
-import { fail } from './error.js';
-export const HTTP_ROUTE_RELEASE_UNAVAILABLE = 'x-astrale-release-unavailable';
-export const HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS = 410;
-export function releaseUnavailableHeaders() {
-    return Object.freeze({
-        [HTTP_ROUTE_RELEASE_UNAVAILABLE]: '1',
-        'cache-control': 'no-store',
-    });
-}
-export function decodeReleaseUnavailable(status, headers) {
-    const encoded = header(headers, HTTP_ROUTE_RELEASE_UNAVAILABLE);
-    if (encoded === undefined)
-        return undefined;
-    if (status !== HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS || encoded !== '1') {
-        fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_ROUTE_RELEASE_UNAVAILABLE} is reserved for status ${HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS} with value 1.`);
-    }
-    return Object.freeze({ kind: 'release-unavailable' });
-}
-function header(input, name) {
-    if (input instanceof Headers)
-        return input.get(name) ?? undefined;
-    let found;
-    for (const [candidate, value] of Object.entries(input ?? {})) {
-        if (candidate.toLowerCase() !== name || value === undefined)
-            continue;
-        if (found !== undefined || (Array.isArray(value) && value.length !== 1)) {
-            fail('NATIVE_ROUTE_ROUTING_INVALID', `Header ${name} must occur at most once.`);
-        }
-        found = typeof value === 'string' ? value : value[0];
-    }
-    return found;
-}