@serve.zone/appstore 32.27.0 → 33.0.0

package/dist_ts_client/catalog.d.ts

@@ -0,0 +1,16 @@
+import type * as plugins from './plugins.js';
+type TCatalog = plugins.servezoneInterfaces.appstore.IAppStoreCatalog;
+type TCatalogApp = plugins.servezoneInterfaces.appstore.IAppStoreCatalogApp;
+type TCatalogVersion = plugins.servezoneInterfaces.appstore.IAppStoreCatalogVersion;
+/** The npm package that carries the signed App Store catalog. */
+export declare const appStoreCatalogPackageName = "@serve.zone/appstore";
+/** Where the signed envelope sits inside the published package (and its `./catalog.envelope.json` export). */
+export declare const appStoreCatalogEnvelopePackagePath = "dist_catalog/catalog.envelope.json";
+/** The app a catalog lists under `appIdArg`. */
+export declare const findAppStoreCatalogApp: (catalogArg: TCatalog, appIdArg: string) => TCatalogApp | undefined;
+/**
+ * The listed `app@version`, withdrawn ones included: an installed service keeps reading its
+ * version. Whether it is an install or upgrade target is `appstore.judgeAppStoreCatalogInstallTarget`.
+ */
+export declare const findAppStoreCatalogVersion: (catalogArg: TCatalog, appIdArg: string, versionArg: string) => TCatalogVersion | undefined;
+export {};

package/dist_ts_client/catalog.js

@@ -0,0 +1,12 @@
+/** The npm package that carries the signed App Store catalog. */
+export const appStoreCatalogPackageName = '@serve.zone/appstore';
+/** Where the signed envelope sits inside the published package (and its `./catalog.envelope.json` export). */
+export const appStoreCatalogEnvelopePackagePath = 'dist_catalog/catalog.envelope.json';
+/** The app a catalog lists under `appIdArg`. */
+export const findAppStoreCatalogApp = (catalogArg, appIdArg) => catalogArg.apps.find((appArg) => appArg.info.id === appIdArg);
+/**
+ * The listed `app@version`, withdrawn ones included: an installed service keeps reading its
+ * version. Whether it is an install or upgrade target is `appstore.judgeAppStoreCatalogInstallTarget`.
+ */
+export const findAppStoreCatalogVersion = (catalogArg, appIdArg, versionArg) => findAppStoreCatalogApp(catalogArg, appIdArg)?.versions.find((entryArg) => entryArg.version === versionArg);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2F0YWxvZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2NsaWVudC9jYXRhbG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLGlFQUFpRTtBQUNqRSxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyxzQkFBc0IsQ0FBQztBQUVqRSw4R0FBOEc7QUFDOUcsTUFBTSxDQUFDLE1BQU0sa0NBQWtDLEdBQUcsb0NBQW9DLENBQUM7QUFFdkYsZ0RBQWdEO0FBQ2hELE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLENBQUMsVUFBb0IsRUFBRSxRQUFnQixFQUEyQixFQUFFLENBQ3hHLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsS0FBSyxRQUFRLENBQUMsQ0FBQztBQUVoRTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyxDQUN4QyxVQUFvQixFQUNwQixRQUFnQixFQUNoQixVQUFrQixFQUNXLEVBQUUsQ0FDL0Isc0JBQXNCLENBQUMsVUFBVSxFQUFFLFFBQVEsQ0FBQyxFQUFFLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxPQUFPLEtBQUssVUFBVSxDQUFDLENBQUMifQ==

package/dist_ts_client/index.d.ts

@@ -1,3 +1,5 @@
-export * from './classes.appstoreresolver.js';
+export * from './catalog.js';
+export * from './loader.js';
+export * from './projection.js';
 export * from './storage.js';
 export * from './types.js';

package/dist_ts_client/index.js

@@ -1,4 +1,6 @@
-export * from './classes.appstoreresolver.js';
+export * from './catalog.js';
+export * from './loader.js';
+export * from './projection.js';
 export * from './storage.js';
 export * from './types.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19jbGllbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFlBQVksQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19jbGllbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFlBQVksQ0FBQyJ9

package/dist_ts_client/loader.d.ts

@@ -0,0 +1,69 @@
+import * as plugins from './plugins.js';
+import type { IAppStoreCatalogLoadOptions, IAppStoreCatalogLoaderOptions, IAppStoreCatalogStoredRecord, TAppStoreCatalogJudgement, TAppStoreCatalogLoadResult, TAppStoreCatalogRestoreResult } from './types.js';
+type TEnvelope = plugins.servezoneInterfaces.appstore.IAppStoreCatalogEnvelope;
+/**
+ * Loads the signed App Store catalog from npm registries and judges it against the consumer's
+ * active catalog. It holds the consumer's options only: no timer, no schedule, no catalog.
+ *
+ * One load asks every configured registry for the package its `latest` dist-tag names, downloads
+ * the tarball, checks it against the registry's `dist.integrity`, extracts the envelope, verifies
+ * it against the trusted keys (`verifyAppStoreCatalogEnvelope`) and judges its succession
+ * (`judgeAppStoreCatalogSuccession`). The first registry whose catalog activates ends the load;
+ * otherwise the result is the first `unchanged`, else the first `refused`, else `failed`, and
+ * `registries` reports what each registry answered.
+ *
+ * The loader holds no state, runs no schedule and persists nothing: the consumer's catalog runtime
+ * owns the one refresh schedule of its process, passes its active envelope in, stores an activated
+ * one as its last-known-good catalog and restores it with `restoreEnvelopeText` at start. Every
+ * request is bounded in time and size; a transport, integrity or packaging failure and every
+ * refusal are results, never thrown. Aborting `signal` (the consumer stopping) ends the load at
+ * once and rejects it with the signal's reason; no attempt is reported for it.
+ */
+export declare class AppStoreCatalogLoader {
+    private readonly trustedKeys;
+    private readonly supportedFeatureIds;
+    private readonly registries;
+    private readonly fetchFunction;
+    private readonly now;
+    private readonly requestTimeoutMs;
+    private readonly maximumTarballBytes;
+    private readonly maximumUnpackedBytes;
+    constructor(optionsArg: IAppStoreCatalogLoaderOptions);
+    /** One load from the configured registries; see the class description. */
+    loadFromRegistries(activeArg: TEnvelope | null, optionsArg?: IAppStoreCatalogLoadOptions): Promise<TAppStoreCatalogLoadResult>;
+    /**
+     * Judges an envelope an operator imported (an offline signed bundle, or the envelope a package
+     * carries at `./catalog.envelope.json`) exactly as a fetched one: authentication, contract,
+     * schema, digests, then succession against the active catalog.
+     */
+    judgeImportedEnvelope(candidateArg: unknown, activeArg: TEnvelope | null): Promise<TAppStoreCatalogJudgement>;
+    /** An envelope read as text: bytes that are not JSON are refused as `schemaInvalid`. */
+    judgeImportedEnvelopeText(textArg: string, activeArg: TEnvelope | null): Promise<TAppStoreCatalogJudgement>;
+    /**
+     * Restores the last-known-good catalog a consumer stored, at start: the stored envelope text is
+     * verified again against today's trusted keys and supported features, exactly as a fetched one,
+     * and answers the status `active` member it activates (`origin` and `loadedAt` as stored, the
+     * verifying key as verified now) or the refusal that keeps it inactive, e.g. `signatureInvalid`
+     * once its key is no longer trusted.
+     */
+    restoreEnvelopeText(textArg: string, recordArg: IAppStoreCatalogStoredRecord): Promise<TAppStoreCatalogRestoreResult>;
+    private judgeText;
+    /** Envelope text as a value; bytes that are not JSON are a `schemaInvalid` refusal. */
+    private parseEnvelopeText;
+    private judge;
+    /**
+     * Authenticates and reads a candidate (`verifyAppStoreCatalogEnvelope`), before and without
+     * succession. The verifier answers every refusal as a result; should it throw, the candidate is
+     * refused as `schemaInvalid` with the cause, so a load never fails on an input it could not read.
+     */
+    private verify;
+    /** The envelope text the package the registry's `latest` dist-tag names carries. */
+    private fetchEnvelopeText;
+    /**
+     * GET with the request bound covering the response body and a byte bound on the body. The
+     * caller's `signalArg` aborts it too; that abort is rethrown as the signal's reason. A redirect is
+     * never followed: a registry that answers with one fails, so a request never leaves https.
+     */
+    private fetchBytes;
+}
+export {};

package/dist_ts_client/loader.js

@@ -0,0 +1,361 @@
+import * as plugins from './plugins.js';
+import { appStoreCatalogEnvelopePackagePath, appStoreCatalogPackageName, } from './catalog.js';
+const defaultRequestTimeoutMs = 30_000;
+const defaultMaximumTarballBytes = 32 * 1024 * 1024;
+const maximumManifestBytes = 1024 * 1024;
+const maximumEnvelopeBytes = 16 * 1024 * 1024;
+const defaultMaximumUnpackedBytes = 256 * 1024 * 1024;
+const envelopeTarballEntryName = `package/${appStoreCatalogEnvelopePackagePath}`;
+/** A failure of the transport, the integrity check or the package layout: no candidate was read. */
+class AppStoreCatalogTransportError extends Error {
+}
+const isRecord = (valueArg) => typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+const isPositiveSafeInteger = (valueArg) => Number.isSafeInteger(valueArg) && valueArg > 0;
+const toBase64 = (bytesArg) => {
+    let binary = '';
+    for (const byte of bytesArg)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+};
+/** The `sha512-<base64>` values of an npm `dist.integrity` (Subresource Integrity syntax). */
+const readSha512Integrity = (integrityArg) => integrityArg.split(/\s+/)
+    .filter((entryArg) => entryArg.startsWith('sha512-'))
+    .map((entryArg) => entryArg.slice('sha512-'.length).replace(/\?.*$/, ''));
+/**
+ * Loads the signed App Store catalog from npm registries and judges it against the consumer's
+ * active catalog. It holds the consumer's options only: no timer, no schedule, no catalog.
+ *
+ * One load asks every configured registry for the package its `latest` dist-tag names, downloads
+ * the tarball, checks it against the registry's `dist.integrity`, extracts the envelope, verifies
+ * it against the trusted keys (`verifyAppStoreCatalogEnvelope`) and judges its succession
+ * (`judgeAppStoreCatalogSuccession`). The first registry whose catalog activates ends the load;
+ * otherwise the result is the first `unchanged`, else the first `refused`, else `failed`, and
+ * `registries` reports what each registry answered.
+ *
+ * The loader holds no state, runs no schedule and persists nothing: the consumer's catalog runtime
+ * owns the one refresh schedule of its process, passes its active envelope in, stores an activated
+ * one as its last-known-good catalog and restores it with `restoreEnvelopeText` at start. Every
+ * request is bounded in time and size; a transport, integrity or packaging failure and every
+ * refusal are results, never thrown. Aborting `signal` (the consumer stopping) ends the load at
+ * once and rejects it with the signal's reason; no attempt is reported for it.
+ */
+export class AppStoreCatalogLoader {
+    trustedKeys;
+    supportedFeatureIds;
+    registries;
+    fetchFunction;
+    now;
+    requestTimeoutMs;
+    maximumTarballBytes;
+    maximumUnpackedBytes;
+    constructor(optionsArg) {
+        if (optionsArg.trustedKeys.length === 0) {
+            throw new Error('App Store catalog loader needs at least one trusted key');
+        }
+        this.trustedKeys = optionsArg.trustedKeys.map((keyArg) => ({ ...keyArg }));
+        this.supportedFeatureIds = [...new Set(optionsArg.supportedFeatureIds)].sort();
+        this.registries = plugins.servezoneInterfaces.appstore.resolveAppStoreCatalogRegistries(optionsArg.registries);
+        this.fetchFunction = optionsArg.fetch ?? ((inputArg, initArg) => fetch(inputArg, initArg));
+        this.now = optionsArg.now ?? (() => new Date());
+        this.requestTimeoutMs = optionsArg.requestTimeoutMs ?? defaultRequestTimeoutMs;
+        this.maximumTarballBytes = optionsArg.maximumTarballBytes ?? defaultMaximumTarballBytes;
+        this.maximumUnpackedBytes = optionsArg.maximumUnpackedBytes ?? defaultMaximumUnpackedBytes;
+        if (!isPositiveSafeInteger(this.requestTimeoutMs)) {
+            throw new Error('App Store catalog requestTimeoutMs must be a positive integer');
+        }
+        if (!isPositiveSafeInteger(this.maximumTarballBytes)) {
+            throw new Error('App Store catalog maximumTarballBytes must be a positive integer');
+        }
+        if (!isPositiveSafeInteger(this.maximumUnpackedBytes)) {
+            throw new Error('App Store catalog maximumUnpackedBytes must be a positive integer');
+        }
+    }
+    /** One load from the configured registries; see the class description. */
+    async loadFromRegistries(activeArg, optionsArg = {}) {
+        const { signal } = optionsArg;
+        const reports = [];
+        const judgements = [];
+        for (const registry of this.registries) {
+            signal?.throwIfAborted();
+            try {
+                const { packageVersion, envelopeText } = await this.fetchEnvelopeText(registry, signal);
+                const judgement = await this.judgeText(envelopeText, activeArg, 'registry');
+                judgements.push(judgement);
+                reports.push({
+                    registry,
+                    outcome: judgement.outcome,
+                    packageVersion,
+                    ...(judgement.outcome === 'refused' ? { message: judgement.refused.message } : {}),
+                });
+                if (judgement.outcome === 'activated')
+                    break;
+            }
+            catch (error) {
+                signal?.throwIfAborted();
+                if (!(error instanceof AppStoreCatalogTransportError))
+                    throw error;
+                reports.push({ registry, outcome: 'failed', message: error.message });
+            }
+        }
+        signal?.throwIfAborted();
+        const chosen = judgements.find((judgementArg) => judgementArg.outcome === 'activated')
+            ?? judgements.find((judgementArg) => judgementArg.outcome === 'unchanged')
+            ?? judgements.find((judgementArg) => judgementArg.outcome === 'refused');
+        if (chosen !== undefined)
+            return { ...chosen, registries: reports };
+        const message = reports.map((reportArg) => `${reportArg.registry}: ${reportArg.message ?? reportArg.outcome}`).join('; ');
+        const failure = {
+            outcome: 'failed',
+            message,
+            attempt: { at: this.now().toISOString(), outcome: 'failed', message },
+        };
+        return { ...failure, registries: reports };
+    }
+    /**
+     * Judges an envelope an operator imported (an offline signed bundle, or the envelope a package
+     * carries at `./catalog.envelope.json`) exactly as a fetched one: authentication, contract,
+     * schema, digests, then succession against the active catalog.
+     */
+    async judgeImportedEnvelope(candidateArg, activeArg) {
+        return await this.judge(candidateArg, activeArg, 'operatorImport');
+    }
+    /** An envelope read as text: bytes that are not JSON are refused as `schemaInvalid`. */
+    async judgeImportedEnvelopeText(textArg, activeArg) {
+        return await this.judgeText(textArg, activeArg, 'operatorImport');
+    }
+    /**
+     * Restores the last-known-good catalog a consumer stored, at start: the stored envelope text is
+     * verified again against today's trusted keys and supported features, exactly as a fetched one,
+     * and answers the status `active` member it activates (`origin` and `loadedAt` as stored, the
+     * verifying key as verified now) or the refusal that keeps it inactive, e.g. `signatureInvalid`
+     * once its key is no longer trusted.
+     */
+    async restoreEnvelopeText(textArg, recordArg) {
+        const candidate = this.parseEnvelopeText(textArg);
+        const verified = candidate.parsed
+            ? await this.verify(candidate.value, recordArg.origin)
+            : refuseCandidate(undefined, this.now().toISOString(), candidate.refusal);
+        if (verified.outcome === 'refused')
+            return verified;
+        return {
+            outcome: 'restored',
+            envelope: verified.envelope,
+            active: { ...verified.active, loadedAt: recordArg.loadedAt },
+        };
+    }
+    async judgeText(textArg, activeArg, originArg) {
+        const candidate = this.parseEnvelopeText(textArg);
+        return candidate.parsed
+            ? await this.judge(candidate.value, activeArg, originArg)
+            : refuseCandidate(undefined, this.now().toISOString(), candidate.refusal);
+    }
+    /** Envelope text as a value; bytes that are not JSON are a `schemaInvalid` refusal. */
+    parseEnvelopeText(textArg) {
+        try {
+            return { parsed: true, value: JSON.parse(textArg) };
+        }
+        catch {
+            return { parsed: false, refusal: { reason: 'schemaInvalid', message: 'envelope is not JSON' } };
+        }
+    }
+    async judge(candidateArg, activeArg, originArg) {
+        const verified = await this.verify(candidateArg, originArg);
+        if (verified.outcome === 'refused')
+            return verified;
+        const succession = plugins.servezoneInterfaces.appstore.judgeAppStoreCatalogSuccession(activeArg, verified.envelope);
+        if (succession.outcome === 'refused')
+            return refuseCandidate(candidateArg, verified.attempt.at, succession.refusal);
+        if (succession.outcome === 'unchanged') {
+            return { outcome: 'unchanged', attempt: { at: verified.attempt.at, outcome: 'unchanged' } };
+        }
+        return verified;
+    }
+    /**
+     * Authenticates and reads a candidate (`verifyAppStoreCatalogEnvelope`), before and without
+     * succession. The verifier answers every refusal as a result; should it throw, the candidate is
+     * refused as `schemaInvalid` with the cause, so a load never fails on an input it could not read.
+     */
+    async verify(candidateArg, originArg) {
+        const at = this.now().toISOString();
+        let verification;
+        try {
+            verification = await plugins.servezoneInterfacesRuntime.verifyAppStoreCatalogEnvelope(candidateArg, {
+                trustedKeys: this.trustedKeys,
+                supportedFeatureIds: this.supportedFeatureIds,
+            });
+        }
+        catch (error) {
+            return refuseCandidate(candidateArg, at, {
+                reason: 'schemaInvalid',
+                message: `envelope could not be verified: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+        if (!verification.accepted)
+            return refuseCandidate(candidateArg, at, verification.refusal);
+        const { envelope, keyId } = verification;
+        const { catalog, catalogDigest } = envelope;
+        return {
+            outcome: 'activated',
+            envelope,
+            active: {
+                contract: { ...catalog.contract },
+                revision: catalog.revision,
+                catalogDigest,
+                publishedAt: catalog.publishedAt,
+                sourceRevision: catalog.sourceRevision,
+                loadedAt: at,
+                keyId,
+                origin: originArg,
+            },
+            attempt: { at, outcome: 'activated' },
+        };
+    }
+    /** The envelope text the package the registry's `latest` dist-tag names carries. */
+    async fetchEnvelopeText(registryArg, signalArg) {
+        const manifestUrl = `${registryArg}/${appStoreCatalogPackageName.replace('/', '%2f')}/latest`;
+        const manifestBytes = await this.fetchBytes(manifestUrl, maximumManifestBytes, signalArg);
+        let manifest;
+        try {
+            manifest = JSON.parse(new TextDecoder().decode(manifestBytes));
+        }
+        catch {
+            throw new AppStoreCatalogTransportError(`${manifestUrl} did not answer JSON`);
+        }
+        const dist = isRecord(manifest) ? manifest.dist : undefined;
+        if (!isRecord(manifest) || manifest.name !== appStoreCatalogPackageName || typeof manifest.version !== 'string'
+            || !isRecord(dist) || typeof dist.tarball !== 'string' || typeof dist.integrity !== 'string') {
+            throw new AppStoreCatalogTransportError(`${manifestUrl} is not the ${appStoreCatalogPackageName} version manifest`);
+        }
+        const packageVersion = manifest.version;
+        const expectedSha512 = readSha512Integrity(dist.integrity);
+        if (expectedSha512.length === 0) {
+            throw new AppStoreCatalogTransportError(`${appStoreCatalogPackageName}@${packageVersion} has no sha512 dist.integrity`);
+        }
+        let tarballUrl;
+        try {
+            tarballUrl = new URL(dist.tarball);
+        }
+        catch {
+            throw new AppStoreCatalogTransportError(`${appStoreCatalogPackageName}@${packageVersion} names no tarball URL`);
+        }
+        if (tarballUrl.protocol !== 'https:' || tarballUrl.username !== '' || tarballUrl.password !== '') {
+            throw new AppStoreCatalogTransportError(`${appStoreCatalogPackageName}@${packageVersion} tarball URL must be https without credentials`);
+        }
+        const tarball = await this.fetchBytes(tarballUrl.toString(), this.maximumTarballBytes, signalArg);
+        const actualSha512 = toBase64(new Uint8Array(await crypto.subtle.digest('SHA-512', tarball)));
+        if (!expectedSha512.includes(actualSha512)) {
+            throw new AppStoreCatalogTransportError(`${appStoreCatalogPackageName}@${packageVersion} tarball does not match its dist.integrity`);
+        }
+        const envelopeText = await readTarballEntry(tarball, envelopeTarballEntryName, packageVersion, this.maximumUnpackedBytes);
+        return { packageVersion, envelopeText };
+    }
+    /**
+     * GET with the request bound covering the response body and a byte bound on the body. The
+     * caller's `signalArg` aborts it too; that abort is rethrown as the signal's reason. A redirect is
+     * never followed: a registry that answers with one fails, so a request never leaves https.
+     */
+    async fetchBytes(urlArg, maximumBytesArg, signalArg) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+        const signal = signalArg === undefined ? controller.signal : AbortSignal.any([controller.signal, signalArg]);
+        try {
+            const response = await this.fetchFunction(urlArg, {
+                signal,
+                redirect: 'error',
+                headers: { accept: 'application/json, application/octet-stream' },
+            });
+            if (!response.ok) {
+                await response.body?.cancel();
+                throw new AppStoreCatalogTransportError(`HTTP ${response.status} for ${urlArg}`);
+            }
+            const declaredLength = Number(response.headers.get('content-length') ?? '0');
+            if (declaredLength > maximumBytesArg) {
+                await response.body?.cancel();
+                throw new AppStoreCatalogTransportError(`${urlArg} exceeds ${maximumBytesArg} bytes`);
+            }
+            if (response.body === null)
+                throw new AppStoreCatalogTransportError(`${urlArg} answered no body`);
+            return await readBounded(response.body, maximumBytesArg, urlArg);
+        }
+        catch (error) {
+            signalArg?.throwIfAborted();
+            if (controller.signal.aborted) {
+                throw new AppStoreCatalogTransportError(`${urlArg} timed out after ${this.requestTimeoutMs} ms`);
+            }
+            if (error instanceof AppStoreCatalogTransportError)
+                throw error;
+            throw new AppStoreCatalogTransportError(`${urlArg} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+/** The refusal record and attempt of a candidate, with its revision when it can be read. */
+const refuseCandidate = (candidateArg, atArg, refusalArg) => {
+    const revision = readCandidateRevision(candidateArg);
+    return {
+        outcome: 'refused',
+        refused: { ...refusalArg, at: atArg, ...(revision === undefined ? {} : { revision }) },
+        attempt: { at: atArg, outcome: 'refused', message: `${refusalArg.reason}: ${refusalArg.message}` },
+    };
+};
+const readCandidateRevision = (candidateArg) => {
+    const catalog = isRecord(candidateArg) ? candidateArg.catalog : undefined;
+    const revision = isRecord(catalog) ? catalog.revision : undefined;
+    return typeof revision === 'number' && Number.isSafeInteger(revision) ? revision : undefined;
+};
+const readBounded = async (streamArg, maximumBytesArg, labelArg) => {
+    const reader = streamArg.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maximumBytesArg) {
+                await reader.cancel();
+                throw new AppStoreCatalogTransportError(`${labelArg} exceeds ${maximumBytesArg} bytes`);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+};
+/**
+ * The text of one regular file in a gzip-compressed npm tarball. The archive is decompressed in
+ * full (bounded) before it is decoded: decoding straight from the decompression stream stalls on
+ * entries larger than one stream chunk.
+ */
+const readTarballEntry = async (tarballArg, entryNameArg, packageVersionArg, maximumUnpackedBytesArg) => {
+    const label = `${appStoreCatalogPackageName}@${packageVersionArg}`;
+    try {
+        const archive = await readBounded(new Blob([tarballArg]).stream().pipeThrough(new DecompressionStream('gzip')), maximumUnpackedBytesArg, `${label} unpacked tarball`);
+        const entry = (await plugins.modernTar.unpackTar(archive, { strict: true }))
+            .find((entryArg) => entryArg.header.name === entryNameArg && (entryArg.header.type ?? 'file') === 'file');
+        if (entry?.data === undefined) {
+            throw new AppStoreCatalogTransportError(`${label} carries no ${appStoreCatalogEnvelopePackagePath}`);
+        }
+        if (entry.data.byteLength > maximumEnvelopeBytes) {
+            throw new AppStoreCatalogTransportError(`${label} ${appStoreCatalogEnvelopePackagePath} exceeds ${maximumEnvelopeBytes} bytes`);
+        }
+        return new TextDecoder().decode(entry.data);
+    }
+    catch (error) {
+        if (error instanceof AppStoreCatalogTransportError)
+            throw error;
+        throw new AppStoreCatalogTransportError(`${label} tarball could not be read: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loader.js","sourceRoot":"","sources":["../ts_client/loader.ts"],"names":[],"mappings":"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"}

package/dist_ts_client/plugins.d.ts

@@ -0,0 +1,5 @@
+import * as servezoneInterfaces from '@serve.zone/interfaces';
+import * as servezoneInterfacesRuntime from '@serve.zone/interfaces/runtime';
+export { servezoneInterfaces, servezoneInterfacesRuntime };
+import * as modernTar from 'modern-tar';
+export { modernTar };

package/dist_ts_client/plugins.js

@@ -0,0 +1,8 @@
+// @serve.zone scope
+import * as servezoneInterfaces from '@serve.zone/interfaces';
+import * as servezoneInterfacesRuntime from '@serve.zone/interfaces/runtime';
+export { servezoneInterfaces, servezoneInterfacesRuntime };
+// third party
+import * as modernTar from 'modern-tar';
+export { modernTar };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2NsaWVudC9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssbUJBQW1CLE1BQU0sd0JBQXdCLENBQUM7QUFDOUQsT0FBTyxLQUFLLDBCQUEwQixNQUFNLGdDQUFnQyxDQUFDO0FBRTdFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSwwQkFBMEIsRUFBRSxDQUFDO0FBRTNELGNBQWM7QUFDZCxPQUFPLEtBQUssU0FBUyxNQUFNLFlBQVksQ0FBQztBQUV4QyxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUMifQ==

package/dist_ts_client/projection.d.ts

@@ -0,0 +1,59 @@
+import * as plugins from './plugins.js';
+type TCatalog = plugins.servezoneInterfaces.appstore.IAppStoreCatalog;
+type TCatalogApp = plugins.servezoneInterfaces.appstore.IAppStoreCatalogApp;
+type TAppStoreApp = plugins.servezoneInterfaces.appstore.IAppStoreApp;
+type TAppStoreAppMeta = plugins.servezoneInterfaces.appstore.IAppStoreAppMeta;
+type TVersionState = plugins.servezoneInterfaces.appstore.IAppStoreAppVersionState;
+/** The consumer a projection is for: the feature ids it fulfils, and which host release it is. */
+export interface IAppStoreCatalogProjectionOptions {
+    /** The `requiresFeatures` ids this consumer fulfils, e.g. `appStoreStorageFeatureIds` values. */
+    supportedFeatureIds: Iterable<string>;
+    /** The host and its release, judged against each version's `minOneboxVersion` / `minCloudlyVersion`. */
+    consumer: plugins.servezoneInterfaces.appstore.IAppStoreCatalogConsumer;
+}
+/** The App Store shapes Onebox and Cloudly carry in their views and requests for one app. */
+export interface IAppStoreCatalogAppDisplay {
+    /** The listing entry (`getAppStoreTemplates`). */
+    app: TAppStoreApp;
+    /** The app metadata (`getAppStoreConfig`, the upgrade preview). */
+    meta: TAppStoreAppMeta;
+}
+/** One catalog app as a consumer with its supported feature ids sees it. */
+export interface IAppStoreCatalogAppProjection {
+    appId: string;
+    /** The catalog's `latestVersion`, the publisher's latest, whether or not this consumer may install it. */
+    catalogLatestVersion: string;
+    /**
+     * Every listed version in catalog order, withdrawn, feature-gated and newer-release-gated ones
+     * included, each with `installRefusal` as `appstore.judgeAppStoreCatalogInstallTarget` answers it.
+     */
+    versions: TVersionState[];
+    /**
+     * The newest version this consumer may install, or `null` when none is: every version withdrawn,
+     * gated on a feature it does not fulfil or requiring a newer release of it. Under `semver` the highest install target; under
+     * `branch` the catalog's `latestVersion` when it is one, since branch tokens have no order.
+     */
+    latestInstallableVersion: string | null;
+    /**
+     * The display shapes, or `null` when `latestInstallableVersion` is: their `versions` list only
+     * install targets and their `latestVersion` names `latestInstallableVersion`, so a version
+     * picker built from them never offers a version the consumer refuses; their `versionStates`
+     * state every listed version with its refusal.
+     */
+    display: IAppStoreCatalogAppDisplay | null;
+}
+/**
+ * Projects one catalog app for a consumer: every listed version with its install refusal, the
+ * newest install target for this consumer, and the `IAppStoreApp` / `IAppStoreAppMeta` shapes its App Store views
+ * show. Pure: it reads the catalog app and never changes it.
+ */
+export declare const projectAppStoreCatalogApp: (appArg: TCatalogApp, optionsArg: IAppStoreCatalogProjectionOptions) => IAppStoreCatalogAppProjection;
+/** Projects every catalog app, in catalog order (by id). */
+export declare const projectAppStoreCatalog: (catalogArg: TCatalog, optionsArg: IAppStoreCatalogProjectionOptions) => IAppStoreCatalogAppProjection[];
+/**
+ * The App Store listing a consumer serves (`getAppStoreTemplates`): one `IAppStoreApp` per app
+ * that has an install target for it, in catalog order. An app without one is left out of the
+ * listing; its projection (`projectAppStoreCatalogApp`) still states why.
+ */
+export declare const getAppStoreCatalogListing: (catalogArg: TCatalog, optionsArg: IAppStoreCatalogProjectionOptions) => TAppStoreApp[];
+export {};