handoff-app 1.2.2-7 → 2.0.0-1

package/dist/registry/publish/tokens.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Connected-workspace token publish orchestration.
+ *
+ * `publish tokens [setId]` runs a **fresh token build** (`handoff.fetch()` — Figma extract +
+ * `buildStyles`) so the local `tokens.json` and generated token outputs are current, discovers the
+ * logical sets from that document, then uploads each selected set (its extracted record + generated
+ * artifacts) to the connected registry. Each set is one atomic upsert; a set whose deterministic
+ * `sourceHash` matches the registry's is skipped. Absent sets are never deleted (explicit deletion is
+ * a separate management action).
+ */
+import Handoff from '../../index';
+/**
+ * Publish all discovered token sets, or a single set when `setId` is given. Runs a fresh token build,
+ * skips sets whose content is unchanged on the registry, and reports published/unchanged/failed
+ * counts. A per-set upload failure is collected and never leaves a partially written set (each set is
+ * committed atomically server-side); the run throws at the end if any set failed.
+ */
+export declare const publishTokens: (handoff: Handoff, setId?: string) => Promise<void>;

package/dist/registry/publish/tokens.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Connected-workspace token publish orchestration.
+ *
+ * `publish tokens [setId]` runs a **fresh token build** (`handoff.fetch()` — Figma extract +
+ * `buildStyles`) so the local `tokens.json` and generated token outputs are current, discovers the
+ * logical sets from that document, then uploads each selected set (its extracted record + generated
+ * artifacts) to the connected registry. Each set is one atomic upsert; a set whose deterministic
+ * `sourceHash` matches the registry's is skipped. Absent sets are never deleted (explicit deletion is
+ * a separate management action).
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishTokens = void 0;
+const logger_1 = require("../../utils/logger");
+const stable_stringify_1 = require("../../utils/stable-stringify");
+const client_1 = require("../client");
+const errors_1 = require("./errors");
+const index_1 = require("./index");
+const publish_build_1 = require("./publish-build");
+/**
+ * Deterministic content hash for a token set: the key-order-independent record serialization plus the
+ * path-sorted artifact bytes. Independent of JSON key insertion order, so an unchanged set hashes the
+ * same across rebuilds and skip-unchanged works reliably.
+ */
+const hashTokenSet = (record, artifacts) => {
+    return (0, publish_build_1.hashPathValues)(artifacts.map((artifact) => ({ path: artifact.path, value: artifact.content })), (0, stable_stringify_1.stableStringify)(record));
+};
+/** Assemble one set's publish package from the freshly generated local token output. */
+const buildTokenSetPackage = (handoff, set) => __awaiter(void 0, void 0, void 0, function* () {
+    const artifacts = (yield handoff.store.tokens.getArtifacts(set.id)).map((artifact) => ({
+        path: artifact.path,
+        format: artifact.format,
+        content: artifact.content,
+        contentType: artifact.contentType,
+        hash: (0, publish_build_1.sha256)(artifact.content),
+        size: Buffer.byteLength(artifact.content, 'utf8'),
+    }));
+    return {
+        id: set.id,
+        kind: set.kind,
+        record: set.record,
+        artifacts,
+        build: (0, publish_build_1.createCurrentBuild)({ sourceHash: hashTokenSet(set.record, artifacts) }),
+    };
+});
+/**
+ * Publish all discovered token sets, or a single set when `setId` is given. Runs a fresh token build,
+ * skips sets whose content is unchanged on the registry, and reports published/unchanged/failed
+ * counts. A per-set upload failure is collected and never leaves a partially written set (each set is
+ * committed atomically server-side); the run throws at the end if any set failed.
+ */
+const publishTokens = (handoff, setId) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = (0, index_1.resolveConnectionOrThrow)(handoff);
+    logger_1.Logger.info(setId ? `Building tokens to publish "${setId}"…` : 'Building tokens for publish…');
+    yield handoff.fetch();
+    const allSets = yield handoff.store.tokens.listSets();
+    let targetSets = allSets;
+    if (setId) {
+        const found = allSets.find((set) => set.id === setId);
+        if (!found) {
+            throw new index_1.PublishError(`Token set "${setId}" was not found in the generated tokens. Discovered sets: ${allSets.map((set) => set.id).join(', ') || '(none)'}.`);
+        }
+        targetSets = [found];
+    }
+    const packages = yield Promise.all(targetSets.map((set) => buildTokenSetPackage(handoff, set)));
+    const client = (0, client_1.createRegistryClient)({ baseUrl: connection.url, accessToken: connection.accessToken });
+    let remote = [];
+    try {
+        remote = yield client.listTokenSets();
+    }
+    catch (error) {
+        // If the summary listing fails we simply publish everything (the server still no-ops unchanged sets).
+        logger_1.Logger.info('Could not read current registry token sets; publishing all selected sets.');
+    }
+    const remoteHashById = new Map(remote.map((entry) => [entry.id, entry.sourceHash]));
+    let published = 0;
+    let unchanged = 0;
+    const failed = [];
+    for (const pkg of packages) {
+        const remoteHash = remoteHashById.get(pkg.id);
+        if (remoteHash && remoteHash === pkg.build.sourceHash) {
+            unchanged += 1;
+            logger_1.Logger.info(`Unchanged: ${pkg.id}`);
+            continue;
+        }
+        try {
+            yield client.publishTokens(pkg);
+            published += 1;
+            logger_1.Logger.info(`Published: ${pkg.id} (${pkg.artifacts.length} artifact(s))`);
+        }
+        catch (error) {
+            failed.push({ id: pkg.id, message: (0, errors_1.describePublishError)(error, connection.url, 'token set') });
+        }
+    }
+    logger_1.Logger.success(`Tokens publish complete — ${published} published, ${unchanged} unchanged${failed.length ? `, ${failed.length} failed` : ''}.`);
+    if (failed.length > 0) {
+        for (const failure of failed) {
+            logger_1.Logger.error(`  - ${failure.id}: ${failure.message}`);
+        }
+        throw new index_1.PublishError(`${failed.length} token set(s) failed to publish.`);
+    }
+});
+exports.publishTokens = publishTokens;

package/dist/registry/tokens/sets.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Logical token-set derivation — the pure, dependency-light boundary between the generated token
+ * document and the registry token entity.
+ *
+ * A **logical token set** is the registry entity boundary for tokens. Its stable ids are:
+ *
+ * ```text
+ * foundation/colors
+ * foundation/typography
+ * foundation/effects
+ * component/<componentId>
+ * ```
+ *
+ * The set `record` is the exact slice extracted from the generated `tokens.json`
+ * ({@link CoreTypes.IDocumentationObject}) — no lossy normalization, so new token properties flow
+ * through without a database migration. This module is imported by the store, publish, checkout, and
+ * server ingestion, so it stays free of fs/DB/React dependencies.
+ */
+import type { Types as CoreTypes } from 'handoff-core';
+/** Kind of a logical token set. */
+export type TokenSetKind = 'foundation' | 'component';
+/** A logical token set: its stable id, kind, and the exact extracted token slice. */
+export interface DerivedTokenSet {
+    id: string;
+    kind: TokenSetKind;
+    /** The exact slice from `tokens.json` — `IColorObject[]`/`ITypographyObject[]`/`IEffectObject[]` for a foundation, `IFileComponentObject` for a component. */
+    record: unknown;
+}
+/** The three stable foundation set ids, in deterministic order. */
+export declare const FOUNDATION_SET_IDS: readonly ["foundation/colors", "foundation/typography", "foundation/effects"];
+/** Whether a set id refers to a component token set. */
+export declare const isComponentSet: (id: string) => boolean;
+export declare const isTokenSetId: (id: string) => boolean;
+/** The kind of a set id. */
+export declare const kindForSetId: (id: string) => TokenSetKind;
+/**
+ * The generated-file base name for a set: `colors`/`typography`/`effects` for a foundation, the
+ * component id for a component set. This is the name the style transformers write files under
+ * (`<outDir>/<name>.<format>`).
+ */
+export declare const setNameForId: (id: string) => string;
+/** The `foundations/<type>` page type (`colors`/`typography`/`effects`) for a foundation set id, else null. */
+export declare const foundationTypeForId: (id: string) => string | null;
+/**
+ * Split the generated token document into logical sets: the three foundation sets (each possibly an
+ * empty array) plus one set per component. Foundation sets are always emitted so a set can carry zero
+ * tokens and so a token removed from a set is reflected as a shrunk `record` on republish.
+ */
+export declare const deriveTokenSets: (doc: CoreTypes.IDocumentationObject | null | undefined) => DerivedTokenSet[];
+/** A minimal default token document, used when no local `tokens.json` exists yet on checkout. */
+export declare const emptyTokenDocument: () => CoreTypes.IDocumentationObject;
+/**
+ * Splice a set of logical token sets into a token document, returning the merged document. Untouched
+ * sets are preserved (single-set checkout never clobbers other sets); a foundation set replaces its
+ * `localStyles` slice, a component set replaces `components[<id>]`.
+ */
+export declare const mergeTokenSetsIntoDocument: (existing: CoreTypes.IDocumentationObject | null | undefined, sets: DerivedTokenSet[]) => CoreTypes.IDocumentationObject;
+/** The `localStyles` key backing a `foundations/<type>` page (`colors`→`color`, `effects`→`effect`). */
+export declare const localStylesKeyForFoundationType: (type: string) => keyof CoreTypes.IDocumentationObject["localStyles"] | null;

package/dist/registry/tokens/sets.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Logical token-set derivation — the pure, dependency-light boundary between the generated token
+ * document and the registry token entity.
+ *
+ * A **logical token set** is the registry entity boundary for tokens. Its stable ids are:
+ *
+ * ```text
+ * foundation/colors
+ * foundation/typography
+ * foundation/effects
+ * component/<componentId>
+ * ```
+ *
+ * The set `record` is the exact slice extracted from the generated `tokens.json`
+ * ({@link CoreTypes.IDocumentationObject}) — no lossy normalization, so new token properties flow
+ * through without a database migration. This module is imported by the store, publish, checkout, and
+ * server ingestion, so it stays free of fs/DB/React dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localStylesKeyForFoundationType = exports.mergeTokenSetsIntoDocument = exports.emptyTokenDocument = exports.deriveTokenSets = exports.foundationTypeForId = exports.setNameForId = exports.kindForSetId = exports.isTokenSetId = exports.isComponentSet = exports.FOUNDATION_SET_IDS = void 0;
+const path_1 = require("../path");
+/** The three stable foundation set ids, in deterministic order. */
+exports.FOUNDATION_SET_IDS = ['foundation/colors', 'foundation/typography', 'foundation/effects'];
+/**
+ * Map a foundation set name (the segment after `foundation/`, and the generated-file base name) to
+ * its `localStyles` key. Note the plural set names (`colors`/`effects`) map to the core's singular
+ * `localStyles.color`/`localStyles.effect`.
+ */
+const LOCAL_STYLES_KEY_BY_FOUNDATION = {
+    colors: 'color',
+    typography: 'typography',
+    effects: 'effect',
+};
+/** Whether a set id refers to a component token set. */
+const isComponentSet = (id) => id.startsWith('component/');
+exports.isComponentSet = isComponentSet;
+const isTokenSetId = (id) => {
+    if (exports.FOUNDATION_SET_IDS.includes(id)) {
+        return true;
+    }
+    return (0, exports.isComponentSet)(id) && (0, path_1.isSafePathSegment)(id.slice('component/'.length));
+};
+exports.isTokenSetId = isTokenSetId;
+/** The kind of a set id. */
+const kindForSetId = (id) => ((0, exports.isComponentSet)(id) ? 'component' : 'foundation');
+exports.kindForSetId = kindForSetId;
+/**
+ * The generated-file base name for a set: `colors`/`typography`/`effects` for a foundation, the
+ * component id for a component set. This is the name the style transformers write files under
+ * (`<outDir>/<name>.<format>`).
+ */
+const setNameForId = (id) => { var _a; return ((0, exports.isComponentSet)(id) ? id.slice('component/'.length) : ((_a = id.split('/')[1]) !== null && _a !== void 0 ? _a : id)); };
+exports.setNameForId = setNameForId;
+/** The `foundations/<type>` page type (`colors`/`typography`/`effects`) for a foundation set id, else null. */
+const foundationTypeForId = (id) => { var _a; return ((0, exports.isComponentSet)(id) ? null : ((_a = id.split('/')[1]) !== null && _a !== void 0 ? _a : null)); };
+exports.foundationTypeForId = foundationTypeForId;
+/**
+ * Split the generated token document into logical sets: the three foundation sets (each possibly an
+ * empty array) plus one set per component. Foundation sets are always emitted so a set can carry zero
+ * tokens and so a token removed from a set is reflected as a shrunk `record` on republish.
+ */
+const deriveTokenSets = (doc) => {
+    var _a, _b, _c, _d, _e;
+    const localStyles = (_a = doc === null || doc === void 0 ? void 0 : doc.localStyles) !== null && _a !== void 0 ? _a : {};
+    const sets = [
+        { id: 'foundation/colors', kind: 'foundation', record: (_b = localStyles.color) !== null && _b !== void 0 ? _b : [] },
+        { id: 'foundation/typography', kind: 'foundation', record: (_c = localStyles.typography) !== null && _c !== void 0 ? _c : [] },
+        { id: 'foundation/effects', kind: 'foundation', record: (_d = localStyles.effect) !== null && _d !== void 0 ? _d : [] },
+    ];
+    const components = (_e = doc === null || doc === void 0 ? void 0 : doc.components) !== null && _e !== void 0 ? _e : {};
+    for (const componentId of Object.keys(components)) {
+        sets.push({ id: `component/${componentId}`, kind: 'component', record: components[componentId] });
+    }
+    return sets;
+};
+exports.deriveTokenSets = deriveTokenSets;
+/** A minimal default token document, used when no local `tokens.json` exists yet on checkout. */
+const emptyTokenDocument = () => ({
+    localStyles: { color: [], typography: [], effect: [] },
+    components: {},
+    assets: {},
+});
+exports.emptyTokenDocument = emptyTokenDocument;
+/**
+ * Splice a set of logical token sets into a token document, returning the merged document. Untouched
+ * sets are preserved (single-set checkout never clobbers other sets); a foundation set replaces its
+ * `localStyles` slice, a component set replaces `components[<id>]`.
+ */
+const mergeTokenSetsIntoDocument = (existing, sets) => {
+    var _a, _b;
+    const base = existing !== null && existing !== void 0 ? existing : (0, exports.emptyTokenDocument)();
+    const doc = Object.assign(Object.assign({}, base), { localStyles: Object.assign({}, ((_a = base.localStyles) !== null && _a !== void 0 ? _a : (0, exports.emptyTokenDocument)().localStyles)), components: Object.assign({}, ((_b = base.components) !== null && _b !== void 0 ? _b : {})) });
+    for (const set of sets) {
+        if ((0, exports.isComponentSet)(set.id)) {
+            doc.components[(0, exports.setNameForId)(set.id)] = set.record;
+            continue;
+        }
+        const localStylesKey = LOCAL_STYLES_KEY_BY_FOUNDATION[(0, exports.setNameForId)(set.id)];
+        if (localStylesKey) {
+            doc.localStyles[localStylesKey] = set.record;
+        }
+    }
+    return doc;
+};
+exports.mergeTokenSetsIntoDocument = mergeTokenSetsIntoDocument;
+/** The `localStyles` key backing a `foundations/<type>` page (`colors`→`color`, `effects`→`effect`). */
+const localStylesKeyForFoundationType = (type) => { var _a; return (_a = LOCAL_STYLES_KEY_BY_FOUNDATION[type]) !== null && _a !== void 0 ? _a : null; };
+exports.localStylesKeyForFoundationType = localStylesKeyForFoundationType;

package/dist/registry/tokens/transfer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Transfer payload contract for token sets, shared by the connected-workspace publish/checkout client
+ * and the registry-side token ingestion endpoint.
+ *
+ * Tokens are their own transfer concern (a `record` slice + byte-for-byte generated artifacts, no
+ * source files and no artifact reference graph), so they use this dedicated shape rather than the
+ * component/pattern/page {@link import('../transfer').TransferPackage}. Types only — no behavior.
+ */
+import type { TransferBuild } from '../transfer';
+import type { ArtifactBuildStatus } from '../../artifacts/types';
+import type { TokenSetKind } from './sets';
+/** A generated token artifact in a transfer package (CSS/SCSS/Style Dictionary/types/custom output). */
+export interface TokenSetTransferArtifact {
+    /** Registry-safe relative output path under the tokens dir (e.g. `css/colors.css`). */
+    path: string;
+    /** Logical format label (`css`|`scss`|`types`|`styleDictionary`|custom outDir). */
+    format: string;
+    content: string;
+    contentType: string;
+    hash?: string;
+    size?: number;
+}
+/**
+ * The full token set publish package uploaded to `PUT /api/registry/transfer/tokens/:setId`: the
+ * extracted record slice, the generated artifacts, and build metadata keyed by `sourceHash`.
+ */
+export interface TokenSetTransferPackage {
+    id: string;
+    kind: TokenSetKind;
+    /** The exact extracted token slice (`IColorObject[]`/…/`IFileComponentObject`). */
+    record: unknown;
+    artifacts: TokenSetTransferArtifact[];
+    build: TransferBuild;
+}
+/** The checkout payload returned by `GET /api/registry/transfer/tokens/:setId`. */
+export interface TokenSetCheckoutPayload {
+    id: string;
+    kind: TokenSetKind;
+    record: unknown;
+    artifacts: TokenSetTransferArtifact[];
+}
+/** A lightweight token-set summary (`GET /api/registry/transfer/tokens`) driving skip-unchanged + bulk checkout. */
+export interface TokenSetSummary {
+    id: string;
+    kind: TokenSetKind;
+    sourceHash: string | null;
+    status: ArtifactBuildStatus | null;
+}

package/dist/registry/tokens/transfer.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Transfer payload contract for token sets, shared by the connected-workspace publish/checkout client
+ * and the registry-side token ingestion endpoint.
+ *
+ * Tokens are their own transfer concern (a `record` slice + byte-for-byte generated artifacts, no
+ * source files and no artifact reference graph), so they use this dedicated shape rather than the
+ * component/pattern/page {@link import('../transfer').TransferPackage}. Types only — no behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/registry/transfer.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Transfer payload contract shared by the connected-workspace publish client and the registry-side
+ * ingestion endpoint.
+ *
+ * Publish is the only path allowed to set render/build-defining fields, source files, rendered
+ * artifacts, and build metadata. This module is the single shared description of that wire shape so
+ * the CLI (which builds and uploads the package) and the registry API (which validates and ingests
+ * it) never drift. Types only — no runtime behavior.
+ */
+import type { ArtifactBuildStatus, ArtifactKind, ArtifactOwnerKind, ArtifactReference } from '../artifacts/types';
+import type { RegistryTextFileKind } from '../store/types';
+/** Entity kinds that can be transferred (published/checked out). */
+export type TransferEntityKind = 'component' | 'pattern' | 'page';
+/**
+ * A registry-safe source file in a transfer package. Declarations are workspace-only (synthesized on
+ * checkout) and are never present here — `kind` excludes `declaration` by type.
+ */
+export interface TransferFile {
+    /** Registry-safe relative path within the entity (e.g. `Badge.tsx`). */
+    path: string;
+    kind: RegistryTextFileKind;
+    content: string;
+    contentType: string;
+}
+/**
+ * A rendered docs read-model artifact in a transfer package. Carries the structured ownership and
+ * references the registry stores so it can validate, serve, and dedup the artifact without ever
+ * parsing HTML.
+ */
+export interface TransferArtifact {
+    /** Logical artifact path (e.g. `component/badge-primary.html`, `component/main.css`). */
+    path: string;
+    artifactKind: ArtifactKind;
+    content: string;
+    contentType: string;
+    /** What the artifact belongs to — shared/global artifacts are `asset` with a `null` owner id. */
+    ownerKind: ArtifactOwnerKind;
+    ownerId: string | null;
+    /** Structured references this artifact depends on (drives required-reference validation). */
+    references?: ArtifactReference[];
+    formatVersion?: string;
+    hash?: string;
+    size?: number;
+}
+/** Build metadata for the published entity. */
+export interface TransferBuild {
+    status: ArtifactBuildStatus;
+    builtAt?: string;
+    builderVersion?: string;
+    artifactHash?: string;
+    sourceHash?: string;
+    warnings?: string[];
+    error?: string;
+}
+/**
+ * The full publish package uploaded to `PUT /api/registry/transfer/{component|pattern|page}/:id`.
+ * Rendered artifacts are included when the entity has a render pipeline.
+ */
+export interface TransferPackage {
+    /** Normalized component, pattern, or page record stored as the served record. */
+    item: Record<string, unknown>;
+    files: TransferFile[];
+    artifacts: TransferArtifact[];
+    build: TransferBuild;
+}
+/**
+ * The checkout payload returned by `GET /api/registry/transfer/{component|pattern|page}/:id`.
+ * Declarations are omitted because the consuming workspace creates them locally.
+ */
+export interface CheckoutPayload {
+    kind: TransferEntityKind;
+    /** Normalized record used to reconstruct the entity. */
+    item: Record<string, unknown>;
+    files: TransferFile[];
+}

package/dist/registry/transfer.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Transfer payload contract shared by the connected-workspace publish client and the registry-side
+ * ingestion endpoint.
+ *
+ * Publish is the only path allowed to set render/build-defining fields, source files, rendered
+ * artifacts, and build metadata. This module is the single shared description of that wire shape so
+ * the CLI (which builds and uploads the package) and the registry API (which validates and ingests
+ * it) never drift. Types only — no runtime behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/filesystem-assets.d.ts

@@ -0,0 +1,17 @@
+import type { FilesystemStoreContext } from './filesystem';
+import type { AssetContentResource, AssetMetadata, AssetStore } from './types';
+/**
+ * Filesystem backed asset store. Enumerates each collection from the generated `public/api` tree
+ * plus the downloadable ZIP and font archives.
+ */
+export declare class FilesystemAssetStore implements AssetStore {
+    private readonly context;
+    constructor(context: FilesystemStoreContext);
+    private roots;
+    private enumerate;
+    private toMetadata;
+    listCollections(): string[];
+    listAssets(collection: string): AssetMetadata[];
+    getAsset(collection: string, assetPath: string): AssetMetadata | null;
+    getAssetContent(collection: string, assetPath: string): AssetContentResource | null;
+}

package/dist/store/filesystem-assets.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesystemAssetStore = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const layout_1 = require("../registry/assets/layout");
+const sets_1 = require("../registry/assets/sets");
+const sha256 = (bytes) => crypto_1.default.createHash('sha256').update(bytes).digest('hex');
+const isFile = (absolutePath) => {
+    try {
+        return fs_extra_1.default.existsSync(absolutePath) && fs_extra_1.default.statSync(absolutePath).isFile();
+    }
+    catch (_a) {
+        return false;
+    }
+};
+/**
+ * Filesystem backed asset store. Enumerates each collection from the generated `public/api` tree
+ * plus the downloadable ZIP and font archives.
+ */
+class FilesystemAssetStore {
+    constructor(context) {
+        this.context = context;
+    }
+    roots() {
+        var _a, _b, _c, _d, _e, _f;
+        const apiPath = (_b = (_a = this.context).getAssetsApiPath) === null || _b === void 0 ? void 0 : _b.call(_a);
+        const iconsZip = (_d = (_c = this.context).getIconsZipFilePath) === null || _d === void 0 ? void 0 : _d.call(_c);
+        const logosZip = (_f = (_e = this.context).getLogosZipFilePath) === null || _f === void 0 ? void 0 : _f.call(_e);
+        const workingPath = this.context.workingPath;
+        if (!apiPath || !iconsZip || !logosZip || !workingPath) {
+            return null;
+        }
+        return { apiPath, iconsZip, logosZip, workingPath };
+    }
+    enumerate(collection) {
+        var _a;
+        const roots = this.roots();
+        if (!roots) {
+            return [];
+        }
+        if (collection === 'icons' || collection === 'logos') {
+            const entries = [];
+            const collectionJson = `assets/${collection}.json`;
+            let assetObjects = [];
+            try {
+                const raw = fs_extra_1.default.readFileSync((0, layout_1.resolveAssetPhysicalPath)(collectionJson, roots), 'utf8');
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed))
+                    assetObjects = parsed;
+            }
+            catch (_b) {
+                assetObjects = [];
+            }
+            for (const asset of assetObjects) {
+                const logicalPath = `assets/${collection}/${asset.path}`;
+                entries.push({
+                    logicalPath,
+                    name: asset.name,
+                    metadata: { icon: asset.icon, index: asset.index, description: (_a = asset.description) !== null && _a !== void 0 ? _a : null },
+                    absolutePath: (0, layout_1.resolveAssetPhysicalPath)(logicalPath, roots),
+                });
+            }
+            const extras = collection === 'icons'
+                ? [collectionJson, 'icons-sprite.svg', 'icons-sprite-manifest.json', 'icons.zip']
+                : [collectionJson, 'logos.zip'];
+            for (const logicalPath of extras) {
+                entries.push({ logicalPath, name: path_1.default.basename(logicalPath), absolutePath: (0, layout_1.resolveAssetPhysicalPath)(logicalPath, roots) });
+            }
+            return entries.filter((entry) => isFile(entry.absolutePath));
+        }
+        if (collection === 'fonts') {
+            const fontsDir = path_1.default.resolve(roots.workingPath, 'fonts');
+            if (!fs_extra_1.default.existsSync(fontsDir)) {
+                return [];
+            }
+            try {
+                return fs_extra_1.default
+                    .readdirSync(fontsDir)
+                    .filter((file) => file.toLowerCase().endsWith('.zip'))
+                    .map((file) => ({ logicalPath: `fonts/${file}`, name: file, absolutePath: path_1.default.join(fontsDir, file) }))
+                    .filter((entry) => isFile(entry.absolutePath));
+            }
+            catch (_c) {
+                return [];
+            }
+        }
+        return [];
+    }
+    toMetadata(collection, entry, bytes) {
+        var _a;
+        return {
+            collection,
+            path: entry.logicalPath,
+            name: entry.name,
+            contentType: (0, sets_1.assetContentType)(entry.logicalPath),
+            size: bytes.length,
+            contentHash: sha256(bytes),
+            metadata: (_a = entry.metadata) !== null && _a !== void 0 ? _a : null,
+        };
+    }
+    listCollections() {
+        return sets_1.ASSET_COLLECTIONS.filter((collection) => this.enumerate(collection).length > 0);
+    }
+    listAssets(collection) {
+        const out = [];
+        for (const entry of this.enumerate(collection)) {
+            try {
+                out.push(this.toMetadata(collection, entry, fs_extra_1.default.readFileSync(entry.absolutePath)));
+            }
+            catch (_a) {
+                // Skip files that vanished between enumeration and read.
+            }
+        }
+        return out;
+    }
+    getAsset(collection, assetPath) {
+        const entry = this.enumerate(collection).find((candidate) => candidate.logicalPath === assetPath);
+        if (!entry) {
+            return null;
+        }
+        try {
+            return this.toMetadata(collection, entry, fs_extra_1.default.readFileSync(entry.absolutePath));
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    getAssetContent(collection, assetPath) {
+        const entry = this.enumerate(collection).find((candidate) => candidate.logicalPath === assetPath);
+        if (!entry) {
+            return null;
+        }
+        try {
+            const bytes = fs_extra_1.default.readFileSync(entry.absolutePath);
+            return Object.assign(Object.assign({}, this.toMetadata(collection, entry, bytes)), { body: bytes });
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+}
+exports.FilesystemAssetStore = FilesystemAssetStore;