@astrale-os/kernel-protocol 0.5.0-beta.67 → 0.5.0-beta.68

package/dist/publication/legacy-requirements.js

@@ -1,23 +0,0 @@
-import { exact, record } from './content.js';
-import { admitRequirements } from './requirements.js';
-/** Read the retired v2 wire coordinate without exposing it in canonical requirements. */
-export function decodeLegacyRequirements(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, ['authority', 'classes', 'functions', 'profiles'], 'PUBLICATION_INVALID');
-    const { profiles, ...principal } = capabilities;
-    return admitRequirements({
-        capabilities: { ...principal, ...(profiles === undefined ? {} : { core: profiles }) },
-    });
-}
-/** Preserve immutable v2 bytes and the historical installation-target digest vocabulary. */
-export function encodeLegacyRequirements(input) {
-    const { core, ...principal } = input.capabilities;
-    return Object.freeze({
-        capabilities: Object.freeze({
-            ...principal,
-            ...(core === undefined ? {} : { profiles: core }),
-        }),
-    });
-}

package/dist/publication/publication.d.ts

@@ -1,38 +0,0 @@
-import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
-import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
-import type { CallableBinding, ViewBinding } from './bindings/index.js';
-import type { Content } from './content.js';
-import type { Endpoint as DeliveryEndpoint } from './delivery-endpoint.js';
-import type { Etag } from './etag.js';
-import type { Manifest } from './manifest.js';
-import type { PublicationRequirements } from './requirements.js';
-import type { HttpRoute } from './route.js';
-import type { Schema } from './schema.js';
-export declare const PATH: '/.well-known/astrale/domain.json';
-export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=3';
-export declare const LEGACY_MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=2';
-export declare function mediaType(input: Pick<Publication, 'version'>): typeof MEDIA_TYPE | typeof LEGACY_MEDIA_TYPE;
-/** Resolve the canonical Publication URL beneath one exact HTTP(S) serving issuer. */
-export declare function url(input: string): string;
-export interface Publication {
-    readonly format: 'astrale.domain.publication';
-    readonly version: 2 | 3;
-    readonly origin: Key.Origin;
-    readonly identity: {
-        readonly issuer: IssuerId;
-        readonly subject: string;
-    };
-    readonly etag: Etag;
-    readonly schema: Schema;
-    readonly requirements: PublicationRequirements;
-    readonly manifest?: Manifest;
-    readonly bindings: {
-        readonly callables: readonly CallableBinding[];
-        readonly views: readonly ViewBinding[];
-    };
-    readonly routes: readonly HttpRoute[];
-    readonly delivery?: DeliveryEndpoint;
-}
-export declare function seal(input: Content): Publication;
-export declare function accept(input: unknown): Publication;
-export declare function encode(input: Publication): Uint8Array;

package/dist/publication/publication.js

@@ -1,146 +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 { canonicalizeViewBinding } from './bindings/view.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 { decodeLegacyRequirements, encodeLegacyRequirements } from './legacy-requirements.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=3';
-export const LEGACY_MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=2';
-export function mediaType(input) {
-    return input.version === 2 ? LEGACY_MEDIA_TYPE : MEDIA_TYPE;
-}
-/** 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) {
-    const canonical = withoutEtag(acceptPublication({ ...input, etag: 'canonicalizing' }, 'seal'));
-    return acceptPublication({ ...canonical, etag: computeEtag(canonical) }, 'canonical');
-}
-export function accept(input) {
-    const publication = acceptPublication(input, 'wire');
-    if (publication.etag !== computeEtag(withoutEtag(publication))) {
-        fail('PUBLICATION_ETAG_MISMATCH', 'Publication ETag does not match its canonical content.');
-    }
-    return publication;
-}
-export function encode(input) {
-    const wire = input.version === 2
-        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
-        : input;
-    return portable.json.encode(wire);
-}
-function acceptPublication(input, mode) {
-    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 && value.version !== 3)) {
-        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 = value.version === 2 && mode === 'wire'
-        ? decodeLegacyRequirements(value.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) => mode === 'seal' ? canonicalizeViewBinding(entry, origin) : 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 = mode === 'wire' ? admitDigest(value.etag) : value.etag;
-    if (typeof admittedEtag !== 'string')
-        fail('PUBLICATION_INVALID', 'Publication ETag is missing.');
-    return deepFreeze({
-        format: 'astrale.domain.publication',
-        version: value.version,
-        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/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;
-}