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

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

@@ -1,227 +1,370 @@
-import { bundle } from '@astrale-os/kernel-dsl/v1';
-import * as artifact from '../../../artifact/index.js';
-import { json } from '../../../codecs/index.js';
-import * as publication from '../../../publication/index.js';
-import * as runtime from '../../../runtime/index.js';
-export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v1+msgpack';
+import { is as isIssuer } from '@astrale-os/kernel-core/auth/issuer';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
+import { revision as schemaRevision } from '@astrale-os/kernel-dsl/v1/schema/revision';
+import { json } from '@astrale-os/kernel-dsl/value';
+import { admitCallableBinding, admitViewBinding } from '../../../release/bindings/index.js';
+import { withPublicationError } from '../../../release/legacy/error.js';
+import * as publication from '../../../release/legacy/index.js';
+export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v3+json';
+const encoder = new TextEncoder();
+const serializedBundles = new WeakMap();
+const admittedBundles = new Map();
+const MAXIMUM_ADMITTED_BUNDLES = 128;
+// The Bundle travels as its JSON text inside the evidence; string escaping at most doubles it.
+const BUNDLE_ESCAPE_FACTOR = 2;
+// Encoding is bounded by the Server response policy, not by the default portable-value limits.
+const ENCODE_LIMITS = Object.freeze({
+    maxBytes: Number.MAX_SAFE_INTEGER,
+    maxStringBytes: Number.MAX_SAFE_INTEGER,
+});
 export async function encode(input, result) {
-    const fields = selected(input);
-    const wire = result === null ? null : encodeResult(fields, result);
-    const { pack } = await import('msgpackr/pack');
-    return new Uint8Array(pack(wire));
+    const request = admitRequest(input);
+    const wire = request.kind === 'installed'
+        ? acceptInstalledReleases(result)
+        : request.kind === 'bundle'
+            ? encodeDomainBundle(result)
+            : request.kind === 'dependencies'
+                ? encodeDomainDependencies(result)
+                : encodeDomainInfo(result);
+    if (request.kind !== 'installed') {
+        proveRequestedOrigin(request, result);
+    }
+    return encoder.encode(json.serialize(wire, { limits: ENCODE_LIMITS }));
 }
 export async function decode(input, bytes, limits) {
+    const request = admitRequest(input);
     if (!(bytes instanceof Uint8Array))
         invalid('Schema introspection evidence must be binary.');
-    admitLimit(limits.maximumPublicationBytes, 'Publication');
-    admitLimit(limits.maximumBundleBytes, 'Bundle');
-    if (bytes.byteLength > limits.maximumPublicationBytes + limits.maximumBundleBytes + 2_048) {
+    admitLimits(request, limits);
+    const maximumEvidenceBytes = limits.maximumPublicationBytes +
+        (request.kind === 'bundle' ? BUNDLE_ESCAPE_FACTOR * limits.maximumBundleBytes : 0) +
+        4_096;
+    if (bytes.byteLength > maximumEvidenceBytes) {
         invalid('Schema introspection evidence exceeds its declared bounds.');
     }
-    const { unpack } = await import('msgpackr/unpack');
     let decoded;
     try {
-        decoded = unpack(bytes);
+        decoded = json.decode(bytes, {
+            limits: {
+                maxBytes: maximumEvidenceBytes,
+                ...(request.kind === 'bundle' ? { maxStringBytes: limits.maximumBundleBytes } : {}),
+            },
+        });
     }
     catch (cause) {
         throw new TypeError('Schema introspection evidence is malformed.', { cause });
     }
-    if (decoded === null)
-        return null;
-    if (!isRecord(decoded))
-        invalid('Schema introspection result must be an object or null.');
-    const fields = selected(input);
-    exact(decoded, fields, 'Schema introspection result');
-    return decodeResult(fields, decoded, limits);
+    return acceptEvidence(request, decoded, limits);
+}
+/**
+ * Package-private: admit one decoded evidence value for an admitted request. Shared with the
+ * pre-R1 representation in `../legacy/`, which decodes other bytes into this same wire value.
+ */
+export function acceptEvidence(request, decoded, limits) {
+    if (request.kind === 'installed')
+        return acceptInstalledReleases(decoded);
+    const result = request.kind === 'bundle'
+        ? decodeDomainBundle(decoded, limits.maximumBundleBytes)
+        : request.kind === 'dependencies'
+            ? acceptDomainDependencies(decoded)
+            : acceptDomainInfo(decoded);
+    proveRequestedOrigin(request, result);
+    return result;
+}
+/** Package-private: admit the evidence bounds a request declares. Shared with `../legacy/`. */
+export function admitLimits(request, limits) {
+    admitLimit(limits.maximumPublicationBytes, 'Publication');
+    if (request.kind === 'bundle')
+        admitLimit(limits.maximumBundleBytes, 'Bundle');
+}
+function proveRequestedOrigin(request, result) {
+    const origin = request.kind === 'inspect'
+        ? result.origin
+        : result.domain.origin;
+    if (origin !== request.origin)
+        invalid('Schema introspection evidence does not match the requested origin.');
+}
+function encodeDomainDependencies(input) {
+    const admitted = acceptDomainDependencies(input);
+    return Object.freeze({
+        domain: encodeDomainInfo(admitted.domain),
+        dependencies: admitted.dependencies.map((binding) => ({ ...binding })),
+    });
 }
-function encodeResult(fields, result) {
-    exact(result, fields, 'Schema introspection result');
-    const source = fields.includes('source') ? encodeSource(result.source) : undefined;
-    const output = {};
-    for (const field of fields) {
-        switch (field) {
-            case 'state':
-                output.state = state(result.state);
-                break;
-            case 'target':
-                output.target = digest(result.target, 'Installation target');
-                break;
-            case 'source':
-                output.source = source;
-                break;
-            case 'bundle':
-                output.bundle = encodeBundle(result.bundle, result.source);
-                break;
-            case 'readiness':
-                output.readiness =
-                    result.readiness === null ? null : digest(result.readiness, 'Installation readiness');
-                break;
-            case 'capabilities':
-                output.capabilities = capabilities(result.capabilities);
-                break;
+/** Admit dependency bindings: origin-ordered, one per origin, each label agreeing with its revisions. */
+export function acceptDomainDependencies(input) {
+    const value = record(input, 'Domain dependencies result');
+    exact(value, ['dependencies', 'domain'], 'Domain dependencies result');
+    const domain = acceptDomainInfo(value.domain);
+    if (!Array.isArray(value.dependencies))
+        invalid('Domain dependency bindings are invalid.');
+    const dependencies = value.dependencies.map(acceptDependencyBinding);
+    for (const [index, binding] of dependencies.entries()) {
+        const previous = dependencies[index - 1];
+        if (previous !== undefined && previous.origin >= binding.origin) {
+            invalid('Domain dependency bindings must be origin-ordered and unique.');
         }
+        if (binding.origin === domain.origin)
+            invalid('Domain dependency bindings cannot name the Domain.');
     }
-    return Object.freeze(output);
+    return Object.freeze({ domain, dependencies: Object.freeze(dependencies) });
 }
-function decodeResult(fields, input, limits) {
-    const source = fields.includes('source') ? decodeSource(input.source, limits) : undefined;
-    const output = {};
-    for (const field of fields) {
-        switch (field) {
-            case 'state':
-                output.state = state(input.state);
-                break;
-            case 'target':
-                output.target = digest(input.target, 'Installation target');
-                break;
-            case 'source':
-                output.source = source;
-                break;
-            case 'bundle':
-                output.bundle = decodeBundle(input.bundle, source, limits.maximumBundleBytes);
-                break;
-            case 'readiness':
-                output.readiness =
-                    input.readiness === null ? null : digest(input.readiness, 'Installation readiness');
-                break;
-            case 'capabilities':
-                output.capabilities = capabilities(input.capabilities);
-                break;
+function acceptDependencyBinding(input) {
+    const value = record(input, 'Domain dependency binding');
+    exact(value, ['active', 'binding', 'origin', 'pinned'], 'Domain dependency binding');
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid('Domain dependency binding origin is invalid.');
+    }
+    if (typeof value.pinned !== 'string' || !patterns.revision.test(value.pinned)) {
+        invalid('Domain dependency binding pinned revision is invalid.');
+    }
+    if (typeof value.active !== 'string' || !patterns.revision.test(value.active)) {
+        invalid('Domain dependency binding active revision is invalid.');
+    }
+    const expected = value.pinned === value.active ? 'exact' : 'retained';
+    if (value.binding !== expected)
+        invalid('Domain dependency binding label is invalid.');
+    return Object.freeze({
+        origin: value.origin,
+        pinned: value.pinned,
+        active: value.active,
+        binding: expected,
+    });
+}
+/** Admit the installed listing: origin-ordered, one release per origin, each pin of one kind. */
+function acceptInstalledReleases(input) {
+    if (!Array.isArray(input))
+        invalid('Installed releases are invalid.');
+    const releases = input.map(acceptInstalledRelease);
+    for (const [index, installed] of releases.entries()) {
+        const previous = releases[index - 1];
+        if (previous !== undefined && previous.origin >= installed.origin) {
+            invalid('Installed releases must be origin-ordered and unique.');
         }
     }
-    if (output.state === 'ready' && Object.hasOwn(output, 'readiness') && output.readiness === null) {
-        invalid('A ready Installation requires readiness evidence.');
+    return Object.freeze(releases);
+}
+function acceptInstalledRelease(input) {
+    const value = record(input, 'Installed release');
+    exact(value, ['inFlight', 'issuer', 'origin', 'pin', 'revision', 'url'], 'Installed release');
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid('Installed release origin is invalid.');
+    }
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
+        invalid('Installed release revision is invalid.');
     }
-    return Object.freeze(output);
+    const issuer = issuerId(value.issuer, 'Installed release issuer');
+    return Object.freeze({
+        origin: value.origin,
+        revision: value.revision,
+        issuer,
+        url: deploymentUrl(value.url),
+        pin: installedPin(value.pin),
+        inFlight: inFlightIssuers(value.inFlight, issuer),
+    });
 }
-function encodeSource(input) {
-    if (input?.kind === 'builtin') {
+function installedPin(input) {
+    const value = record(input, 'Installed pin');
+    if (value.kind === 'release') {
+        exact(value, ['build', 'kind', 'release'], 'Installed release pin');
         return Object.freeze({
-            kind: 'builtin',
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Builtin schema Bundle'),
+            kind: 'release',
+            release: digest(value.release, 'Installed release'),
+            build: digest(value.build, 'Installed build'),
         });
     }
-    if (input?.kind === 'local') {
+    // Deprecated legacy v2/v3 pin: deleted with the `legacy` variant of `InstalledPin`, in the
+    // breaking release that deletes `runtime/schema/installation/source/legacy/`.
+    if (value.kind === 'legacy') {
+        exact(value, ['document', 'etag', 'kind'], 'Installed legacy pin');
+        if (value.document !== 2 && value.document !== 3) {
+            invalid('Installed legacy pin document version is invalid.');
+        }
         return Object.freeze({
-            kind: 'local',
-            artifact: ref(input.artifact, runtime.MEDIA_TYPE, 'Local Runtime Artifact'),
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Local schema Bundle'),
+            kind: 'legacy',
+            document: value.document,
+            etag: digest(value.etag, 'Installed legacy Publication'),
         });
     }
-    if (input?.kind === 'remote') {
+    return invalid('Installed pin kind is invalid.');
+}
+function inFlightIssuers(input, current) {
+    if (!Array.isArray(input))
+        invalid('Installed release in-flight issuers are invalid.');
+    const entries = input.map((entry) => {
+        const value = record(entry, 'In-flight issuer');
+        exact(value, ['issuer', 'release', 'replacedAt'], 'In-flight issuer');
+        if (typeof value.replacedAt !== 'string' || !isInstant(value.replacedAt)) {
+            invalid('In-flight issuer replacement instant is invalid.');
+        }
         return Object.freeze({
-            kind: 'remote',
-            publication: publication.encode(publication.accept(input.publication)),
+            issuer: issuerId(value.issuer, 'In-flight issuer'),
+            release: digest(value.release, 'In-flight release'),
+            replacedAt: value.replacedAt,
         });
+    });
+    for (const [index, entry] of entries.entries()) {
+        if (entry.issuer === current)
+            invalid('An in-flight issuer cannot be the current issuer.');
+        const previous = entries[index - 1];
+        if (previous !== undefined && previous.issuer >= entry.issuer) {
+            invalid('In-flight issuers must be issuer-ordered and unique.');
+        }
     }
-    return invalid('Installation source is invalid.');
+    return Object.freeze(entries);
 }
-function decodeSource(input, limits) {
-    if (!isRecord(input))
-        invalid('Installation source is invalid.');
-    if (input.kind === 'builtin') {
-        exact(input, ['bundle', 'kind'], 'Builtin installation source');
-        return Object.freeze({
-            kind: 'builtin',
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Builtin schema Bundle'),
-        });
+function issuerId(input, label) {
+    if (!isIssuer(input))
+        invalid(`${label} is invalid.`);
+    return input;
+}
+/** An HTTP(S) origin, spelled exactly as `URL.origin` spells it. */
+function deploymentUrl(input) {
+    let url;
+    try {
+        url = typeof input === 'string' ? new URL(input) : undefined;
     }
-    if (input.kind === 'local') {
-        exact(input, ['artifact', 'bundle', 'kind'], 'Local installation source');
-        return Object.freeze({
-            kind: 'local',
-            artifact: ref(input.artifact, runtime.MEDIA_TYPE, 'Local Runtime Artifact'),
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Local schema Bundle'),
-        });
+    catch {
+        url = undefined;
     }
-    if (input.kind === 'remote') {
-        exact(input, ['kind', 'publication'], 'Remote installation source');
-        const encoded = boundedBytes(input.publication, limits.maximumPublicationBytes, 'Publication');
-        let admitted;
-        try {
-            admitted = publication.accept(json.decode(encoded));
-        }
-        catch (cause) {
-            throw new TypeError('Remote installed Publication is invalid.', { cause });
-        }
-        if (!equal(encoded, publication.encode(admitted))) {
-            invalid('Remote installed Publication is not canonical.');
-        }
-        return Object.freeze({ kind: 'remote', publication: admitted });
+    if (url === undefined || (url.protocol !== 'https:' && url.protocol !== 'http:')) {
+        invalid('Installed release URL is invalid.');
     }
-    return invalid('Installation source kind is invalid.');
+    if (url.origin !== input)
+        invalid('Installed release URL must be an origin.');
+    return url.origin;
+}
+/** A UTC millisecond instant, spelled exactly as `Date.prototype.toISOString` spells it. */
+function isInstant(input) {
+    const time = Date.parse(input);
+    return Number.isFinite(time) && new Date(time).toISOString() === input;
 }
-function encodeBundle(input, source) {
-    if (source === undefined || input === undefined)
-        invalid('Bundle source evidence is missing.');
-    const admitted = source.kind === 'remote'
-        ? publication.acceptBundle(source.publication, input)
-        : bundle.accept(input);
-    const encoded = bundle.encode(admitted);
-    if (source.kind !== 'remote' &&
-        !same(artifact.identify(encoded, publication.BUNDLE_MEDIA_TYPE), source.bundle)) {
-        invalid('Local schema Bundle does not match its source Ref.');
-    }
-    return encoded;
+function encodeDomainBundle(input) {
+    exact(input, ['bundle', 'domain'], 'Domain Bundle result');
+    const admittedDomain = acceptDomainInfo(input.domain);
+    const domain = encodeDomainInfo(admittedDomain);
+    proveBundle(input.bundle, admittedDomain);
+    const text = serializedBundles.get(input.bundle) ?? bundle.serialize(input.bundle);
+    if (!serializedBundles.has(input.bundle))
+        serializedBundles.set(input.bundle, text);
+    return Object.freeze({ domain, bundle: text });
 }
-function decodeBundle(input, source, maximum) {
-    const encoded = boundedBytes(input, maximum, 'Bundle');
+function decodeDomainBundle(input, maximum) {
+    const value = record(input, 'Domain Bundle result');
+    exact(value, ['bundle', 'domain'], 'Domain Bundle result');
+    const domain = acceptDomainInfo(value.domain);
+    const text = boundedText(value.bundle, maximum, 'Bundle');
+    const cached = admittedBundles.get(domain.generation);
+    if (cached !== undefined && cached.text === text) {
+        return Object.freeze({ domain, bundle: cached.bundle });
+    }
     let admitted;
     try {
-        admitted =
-            source.kind === 'remote'
-                ? publication.decodeBundle(source.publication, encoded)
-                : bundle.decode(encoded);
+        admitted = bundle.decode(text);
     }
     catch (cause) {
-        throw new TypeError('Installed schema Bundle is invalid.', { cause });
+        throw new TypeError('Installed Domain Bundle is invalid.', { cause });
+    }
+    proveBundle(admitted, domain);
+    admittedBundles.delete(domain.generation);
+    admittedBundles.set(domain.generation, Object.freeze({ text, bundle: admitted }));
+    if (admittedBundles.size > MAXIMUM_ADMITTED_BUNDLES) {
+        admittedBundles.delete(admittedBundles.keys().next().value);
     }
-    if (!equal(encoded, bundle.encode(admitted)))
-        invalid('Installed schema Bundle is not canonical.');
-    if (source.kind !== 'remote' &&
-        !same(artifact.identify(encoded, publication.BUNDLE_MEDIA_TYPE), source.bundle)) {
-        invalid('Local schema Bundle does not match its source Ref.');
+    return Object.freeze({ domain, bundle: admitted });
+}
+function encodeDomainInfo(input) {
+    return acceptDomainInfo(input);
+}
+export function acceptDomainInfo(input) {
+    const value = record(input, 'Domain info');
+    exact(value, ['bindings', 'capabilities', 'generation', 'origin', 'publication', 'readiness', 'revision'], 'Domain info');
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid('Domain info origin is invalid.');
+    }
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
+        invalid('Domain info revision is invalid.');
+    }
+    const origin = value.origin;
+    const revision = value.revision;
+    const published = publicationReference(value.publication, origin, revision);
+    return Object.freeze({
+        origin,
+        revision,
+        generation: digest(value.generation, 'Domain generation'),
+        publication: published,
+        readiness: digest(value.readiness, 'Domain readiness'),
+        capabilities: capabilities(value.capabilities),
+        bindings: bindings(value.bindings, origin),
+    });
+}
+function publicationReference(input, origin, revision) {
+    if (input === null)
+        return null;
+    let admitted;
+    try {
+        admitted = publication.acceptReference(input);
+    }
+    catch (cause) {
+        throw new TypeError('Domain Publication metadata is invalid.', { cause });
+    }
+    if (admitted.origin !== origin || admitted.revision !== revision) {
+        invalid('Domain Publication metadata does not match its Schema coordinate.');
     }
     return admitted;
 }
-function selected(input) {
-    if (input === null ||
-        typeof input !== 'object' ||
-        input.from?.kind !== 'installation' ||
-        input.select === null ||
-        typeof input.select !== 'object') {
-        invalid('Schema introspection request is invalid.');
-    }
-    const allowed = ['state', 'target', 'source', 'bundle', 'readiness', 'capabilities'];
-    const fields = Object.keys(input.select);
-    if (fields.length === 0 ||
-        fields.some((field) => !allowed.includes(field) ||
-            input.select[field] !== true) ||
-        (input.select.bundle === true && input.select.source !== true)) {
-        invalid('Schema introspection selection is invalid.');
-    }
-    return Object.freeze(allowed.filter((field) => input.select[field] === true));
+function bindings(input, origin) {
+    const value = record(input, 'Domain bindings');
+    exact(value, ['callables', 'views'], 'Domain bindings');
+    const { callables, views } = value;
+    if (!Array.isArray(callables) || !Array.isArray(views)) {
+        invalid('Domain bindings are invalid.');
+    }
+    try {
+        return withPublicationError(() => Object.freeze({
+            callables: Object.freeze(callables.map((entry) => admitCallableBinding(entry, origin))),
+            views: Object.freeze(views.map((entry) => admitViewBinding(entry, origin))),
+        }));
+    }
+    catch (cause) {
+        throw new TypeError('Domain bindings are invalid.', { cause });
+    }
+}
+function proveBundle(input, domain) {
+    if (input.root.origin !== domain.origin || schemaRevision(input.root) !== domain.revision) {
+        invalid('Installed Bundle root does not match the ready Domain coordinate.');
+    }
 }
 function capabilities(input) {
-    if (!isRecord(input))
-        invalid('Installation capabilities are invalid.');
-    exact(input, ['materialized', 'requested'], 'Installation capabilities');
+    const value = record(input, 'Domain capabilities');
+    exact(value, ['materialized', 'requested'], 'Domain capabilities');
     try {
-        const requested = publication.admitRequirements({ capabilities: input.requested }).capabilities;
+        const requested = publication.admitRequirements({ capabilities: value.requested }).capabilities;
         const materialized = publication.admitRequirements({
-            capabilities: input.materialized,
+            capabilities: value.materialized,
         }).capabilities;
         return Object.freeze({ requested, materialized });
     }
     catch (cause) {
-        throw new TypeError('Installation capabilities are invalid.', { cause });
+        throw new TypeError('Domain capabilities are invalid.', { cause });
     }
 }
-function state(input) {
-    if (input !== 'installed' && input !== 'ready' && input !== 'removing') {
-        invalid('Installation state is invalid.');
+/** Package-private: admit one introspection request. Shared with `../legacy/`. */
+export function admitRequest(input) {
+    const value = record(input, 'Schema introspection request');
+    if (value.kind === 'installed') {
+        exact(value, ['kind'], 'Schema introspection request');
+        return Object.freeze({ kind: 'installed' });
     }
-    return input;
+    exact(value, ['kind', 'origin'], 'Schema introspection request');
+    if (value.kind !== 'inspect' && value.kind !== 'bundle' && value.kind !== 'dependencies') {
+        invalid('Schema introspection kind is invalid.');
+    }
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid('Schema introspection origin is invalid.');
+    }
+    return Object.freeze({ kind: value.kind, origin: value.origin });
 }
 function digest(input, label) {
     if (typeof input !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(input)) {
@@ -229,31 +372,24 @@ function digest(input, label) {
     }
     return input;
 }
-function ref(input, mediaType, label) {
-    let admitted;
-    try {
-        admitted = artifact.accept(input);
-    }
-    catch (cause) {
-        throw new TypeError(`${label} Ref is invalid.`, { cause });
-    }
-    if (admitted.mediaType !== mediaType)
-        invalid(`${label} media type is invalid.`);
-    return admitted;
-}
-function same(left, right) {
-    return (left.digest === right.digest && left.mediaType === right.mediaType && left.size === right.size);
-}
-function boundedBytes(input, maximum, label) {
-    if (!(input instanceof Uint8Array) || input.byteLength === 0 || input.byteLength > maximum) {
+function boundedText(input, maximum, label) {
+    if (typeof input !== 'string' ||
+        input.length === 0 ||
+        encoder.encode(input).byteLength > maximum) {
         invalid(`${label} evidence is invalid or exceeds its bound.`);
     }
-    return Uint8Array.from(input);
+    return input;
 }
 function admitLimit(input, label) {
     if (!Number.isSafeInteger(input) || input < 1)
         invalid(`${label} evidence bound is invalid.`);
 }
+function record(input, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        invalid(`${label} is invalid.`);
+    }
+    return input;
+}
 function exact(input, expected, label) {
     const keys = Object.keys(input).sort();
     const wanted = [...expected].sort();
@@ -261,13 +397,6 @@ function exact(input, expected, label) {
         invalid(`${label} fields are invalid.`);
     }
 }
-function equal(left, right) {
-    return left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index]);
-}
-function isRecord(input) {
-    return input !== null && typeof input === 'object' && !Array.isArray(input);
-}
 function invalid(message) {
     throw new TypeError(message);
 }
-//# sourceMappingURL=codec.js.map

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

@@ -1,3 +1,2 @@
-export { MEDIA_TYPE, decode, encode } from './codec.js';
-export type { Digest, Installation, Limits, ResultFor, Source } from './result.js';
-//# sourceMappingURL=index.d.ts.map
+export { MEDIA_TYPE, acceptDomainDependencies, acceptDomainInfo, decode, encode } from './codec.js';
+export type { DependencyBinding, Digest, DomainBundle, DomainDependencies, DomainInfo, InFlightIssuer, InstalledPin, InstalledRelease, Limits, ResultFor, } from './result.js';

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

@@ -1,2 +1 @@
-export { MEDIA_TYPE, decode, encode } from './codec.js';
-//# sourceMappingURL=index.js.map
+export { MEDIA_TYPE, acceptDomainDependencies, acceptDomainInfo, decode, encode } from './codec.js';