@astrale-os/kernel-protocol 0.5.0-beta.71 → 0.5.0-beta.72

package/dist/schema/installation/legacy/introspection.d.ts

@@ -1,10 +0,0 @@
-import type { introspection } from '@astrale-os/kernel-core/schema';
-import type { Limits, ResultFor } from '../introspection/result.js';
-/** @deprecated Read-only: Hosts older than beta.127 serve this; current Hosts serve `introspection.MEDIA_TYPE`. */
-export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-introspection.v2+msgpack';
-/**
- * Decode version-two (MessagePack) introspection evidence into the canonical result.
- *
- * @deprecated Read-only; use `introspection.decode` with `introspection.MEDIA_TYPE`.
- */
-export declare function decode<Input extends introspection.Introspection>(input: Input, bytes: Uint8Array, limits: Limits): Promise<ResultFor<Input>>;

package/dist/schema/installation/legacy/introspection.js

@@ -1,70 +0,0 @@
-import { accept as acceptValue, defaultLimits } from '@astrale-os/kernel-dsl/value';
-import { acceptEvidence, admitLimits, admitRequest } from '../introspection/codec.js';
-import { decode as decodeMessagePack } from './msgpack.js';
-/** @deprecated Read-only: Hosts older than beta.127 serve this; current Hosts serve `introspection.MEDIA_TYPE`. */
-export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v2+msgpack';
-const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
-/**
- * Decode version-two (MessagePack) introspection evidence into the canonical result.
- *
- * @deprecated Read-only; use `introspection.decode` with `introspection.MEDIA_TYPE`.
- */
-export async function decode(input, bytes, limits) {
-    const request = admitRequest(input);
-    if (!(bytes instanceof Uint8Array))
-        invalid('Schema introspection evidence must be binary.');
-    admitLimits(request, limits);
-    // Version two carried the Bundle as raw bytes: no escaping allowance.
-    const maximumEvidenceBytes = limits.maximumPublicationBytes +
-        (request.kind === 'bundle' ? limits.maximumBundleBytes : 0) +
-        4_096;
-    if (bytes.byteLength > maximumEvidenceBytes) {
-        invalid('Schema introspection evidence exceeds its declared bounds.');
-    }
-    let wire;
-    try {
-        wire = decodeMessagePack(bytes, defaultLimits.maxDepth);
-    }
-    catch (cause) {
-        throw new TypeError('Schema introspection evidence is malformed.', { cause });
-    }
-    if (request.kind === 'bundle')
-        wire = bundleAsText(wire);
-    let decoded;
-    try {
-        decoded = acceptValue(wire, {
-            limits: {
-                maxBytes: maximumEvidenceBytes,
-                ...(request.kind === 'bundle' ? { maxStringBytes: limits.maximumBundleBytes } : {}),
-            },
-        });
-    }
-    catch (cause) {
-        throw new TypeError('Schema introspection evidence is malformed.', { cause });
-    }
-    return acceptEvidence(request, decoded, limits);
-}
-/**
- * Version two carried the Bundle as the UTF-8 bytes of its canonical JSON; the current wire value
- * carries that JSON as text. Translate only that field; every other check stays canonical.
- */
-function bundleAsText(wire) {
-    if (wire === null || typeof wire !== 'object' || Array.isArray(wire))
-        return wire;
-    if (!Object.hasOwn(wire, 'bundle'))
-        return wire;
-    const { bundle } = wire;
-    if (!(bundle instanceof Uint8Array))
-        invalid('Bundle evidence is invalid or exceeds its bound.');
-    let text;
-    try {
-        text = utf8.decode(bundle);
-    }
-    catch (cause) {
-        throw new TypeError('Installed Domain Bundle is invalid.', { cause });
-    }
-    return { ...wire, bundle: text };
-}
-function invalid(message) {
-    throw new TypeError(message);
-}

package/dist/schema/installation/legacy/msgpack.d.ts

@@ -1 +0,0 @@
-export declare function decode(bytes: Uint8Array, maximumDepth: number): unknown;

package/dist/schema/installation/legacy/msgpack.js

@@ -1,143 +0,0 @@
-/**
- * Frozen, read-only MessagePack decoder for the schema evidence of Hosts older than beta.127.
- *
- * It reads the families that msgpackr 2.0.5 `pack` (`useRecords: false`) wrote for that evidence:
- * nil, booleans, integers, floats, strings, binary, arrays and string-keyed maps. Extension types
- * (msgpackr records and `undefined`, timestamps, structured clones) never occur in it and are
- * rejected, as are truncated input, trailing bytes, invalid UTF-8, non-string or duplicate map keys,
- * integers outside the safe range, and nesting deeper than `maximumDepth`. It never encodes.
- */
-const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
-export function decode(bytes, maximumDepth) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    let position = 0;
-    const take = (length) => {
-        if (length > bytes.byteLength - position)
-            malformed('is truncated');
-        const start = position;
-        position += length;
-        return start;
-    };
-    const u8 = () => bytes[take(1)];
-    const u16 = () => view.getUint16(take(2));
-    const u32 = () => view.getUint32(take(4));
-    const text = (length) => {
-        const start = take(length);
-        return utf8.decode(bytes.subarray(start, start + length));
-    };
-    const binary = (length) => {
-        const start = take(length);
-        return bytes.slice(start, start + length);
-    };
-    const entries = (count, width) => {
-        // Every entry occupies at least one byte per item: refuse counts the input cannot hold.
-        if (count * width > bytes.byteLength - position)
-            malformed('declares more entries than it holds');
-    };
-    const nested = (depth) => {
-        if (depth >= maximumDepth)
-            malformed(`nests deeper than ${maximumDepth} containers`);
-        return depth + 1;
-    };
-    const array = (count, depth) => {
-        entries(count, 1);
-        const output = [];
-        for (let index = 0; index < count; index += 1)
-            output.push(value(depth));
-        return output;
-    };
-    const map = (count, depth) => {
-        entries(count, 2);
-        const output = {};
-        for (let index = 0; index < count; index += 1) {
-            const key = value(depth);
-            if (typeof key !== 'string')
-                malformed('has a non-string map key');
-            if (Object.hasOwn(output, key))
-                malformed('has a duplicate map key');
-            Object.defineProperty(output, key, {
-                value: value(depth),
-                enumerable: true,
-                writable: true,
-                configurable: true,
-            });
-        }
-        return output;
-    };
-    const integer = (input) => {
-        const output = Number(input);
-        if (!Number.isSafeInteger(output))
-            malformed('holds an integer outside the safe range');
-        return output;
-    };
-    function value(depth) {
-        const head = u8();
-        if (head <= 0x7f)
-            return head;
-        if (head >= 0xe0)
-            return head - 0x100;
-        if (head <= 0x8f)
-            return map(head & 0x0f, nested(depth));
-        if (head <= 0x9f)
-            return array(head & 0x0f, nested(depth));
-        if (head <= 0xbf)
-            return text(head & 0x1f);
-        switch (head) {
-            case 0xc0:
-                return null;
-            case 0xc2:
-                return false;
-            case 0xc3:
-                return true;
-            case 0xc4:
-                return binary(u8());
-            case 0xc5:
-                return binary(u16());
-            case 0xc6:
-                return binary(u32());
-            case 0xca:
-                return view.getFloat32(take(4));
-            case 0xcb:
-                return view.getFloat64(take(8));
-            case 0xcc:
-                return u8();
-            case 0xcd:
-                return u16();
-            case 0xce:
-                return u32();
-            case 0xcf:
-                return integer(view.getBigUint64(take(8)));
-            case 0xd0:
-                return view.getInt8(take(1));
-            case 0xd1:
-                return view.getInt16(take(2));
-            case 0xd2:
-                return view.getInt32(take(4));
-            case 0xd3:
-                return integer(view.getBigInt64(take(8)));
-            case 0xd9:
-                return text(u8());
-            case 0xda:
-                return text(u16());
-            case 0xdb:
-                return text(u32());
-            case 0xdc:
-                return array(u16(), nested(depth));
-            case 0xdd:
-                return array(u32(), nested(depth));
-            case 0xde:
-                return map(u16(), nested(depth));
-            case 0xdf:
-                return map(u32(), nested(depth));
-            default:
-                return malformed(`uses the unsupported type 0x${head.toString(16)}`);
-        }
-    }
-    const output = value(0);
-    if (position !== bytes.byteLength)
-        malformed('has trailing bytes');
-    return output;
-}
-function malformed(reason) {
-    throw new TypeError(`MessagePack evidence ${reason}.`);
-}