@design.estate/wcctools 6.1.0 → 6.2.0

package/dist_ts/classes.devserver.js

@@ -13,81 +13,155 @@ const securityHeaders = {
 };
 const acceptAnyHostname = () => true;
 /**
- * `wcctools dev`: bundles the catalog of the current project with tswatch, as its
- * `@git.zone/tswatch` configuration (or the `element` preset) describes, and serves on one port:
+ * `wcctools dev`: bundles the catalog of a project with tswatch, as its `@git.zone/tswatch`
+ * configuration (or the `element` preset) describes, and serves on one port:
  *
  * - the shell on `/wcctools/` (`/` redirects there) and its routes `/wcctools-route/...`,
- * - the typed API on `/wcctools/typedrequest`,
+ * - the typed API on `/wcctools/typedrequest`, including the bundles' status,
  * - the catalog's preview document and bundle from the tswatch serve directory on every other
  *   path, with live reload that reloads only the preview document.
  *
- * tswatch resolves its paths against the process's working directory, so the server serves the
- * project the process runs in.
+ * The server owns no process lifecycle: while it runs, a process shutdown through smartexit's
+ * `ProcessLifecycle` stops it. The entry point installs that lifecycle with
+ * `getShutdownTimeoutMs()`.
  */
 export class WccDevServer {
     options;
     /** The typed API on `/wcctools/typedrequest`; register further handlers before `start()`. */
     api = new WccDevApi();
-    tsWatch = null;
+    /** The project directory everything resolves against. */
+    cwd;
+    /** The project's tswatch configuration, or the `element` preset; read once, on construction. */
+    config;
+    /** Bundling and watching stay tswatch's; its own server stays off. */
+    tsWatch;
     typedServer = null;
-    smartExit = new plugins.smartexit.SmartExit({ silent: true });
+    /** Stops the server on a process shutdown; registered by start(), released by stop(). */
+    smartExit = null;
+    unsubscribeBundleEvents = null;
+    running = false;
+    starting = null;
+    stopping = null;
     constructor(options = {}) {
         this.options = options;
-        this.smartExit.addCleanupFunction(() => this.stop());
+        this.cwd = plugins.path.resolve(options.cwd ?? process.cwd());
+        const configHandler = new plugins.tswatch.ConfigHandler(this.cwd);
+        this.config = configHandler.loadConfig() ?? this.getElementPreset(configHandler);
+        this.tsWatch = new plugins.tswatch.TsWatch({ ...this.config, server: { enabled: false } }, { cwd: this.cwd });
     }
+    /**
+     * The shutdown deadline the server needs, tswatch's: the entry point installs smartexit's
+     * `ProcessLifecycle` with it, so every watcher command keeps its full grace period.
+     */
+    getShutdownTimeoutMs() {
+        return this.tsWatch.getShutdownTimeoutMs();
+    }
+    /**
+     * Bundles the catalog, starts the watchers and serves. Refused while the server runs or stops;
+     * the server starts again after stop().
+     */
     async start() {
-        if (this.typedServer) {
-            throw new Error('wcctools: the dev server is already started.');
+        if (this.running || this.stopping) {
+            throw new Error('wcctools: the dev server is already started or still stopping.');
         }
-        const cwd = process.cwd();
-        const configHandler = new plugins.tswatch.ConfigHandler(cwd);
-        const config = configHandler.loadConfig() ?? configHandler.getPreset('element');
-        const serveDir = plugins.path.resolve(cwd, config.server?.serveDir ?? defaultServeDir);
-        const port = this.options.port ?? config.server?.port ?? defaultPort;
-        // The preview surface watches the serve directory, which must exist before the first bundle
-        await plugins.fs.mkdir(serveDir, { recursive: true });
-        this.api.setServerInfo({
-            wcctoolsVersion: commitinfo.version,
-            projectName: await this.readProjectName(cwd),
-        });
-        const typedServer = new plugins.typedserver.TypedServer({
-            cors: false,
-            port,
-            surfaces: [
-                await this.createShellSurface(),
-                this.createPreviewSurface(serveDir),
-            ],
-        });
-        this.typedServer = typedServer;
-        // Bundling and watching stay tswatch's; its own server stays off
-        this.tsWatch = new plugins.tswatch.TsWatch({ ...config, server: { enabled: false } });
+        this.running = true;
+        // A process shutdown stops the server from here on, also while it is still starting
+        const smartExit = new plugins.smartexit.SmartExit({ silent: true });
+        smartExit.addCleanupFunction(() => this.stop());
+        this.smartExit = smartExit;
+        const starting = this.startServing();
+        this.starting = starting;
         try {
-            await this.tsWatch.start();
-            await typedServer.start();
+            const address = await starting;
+            if (this.stopping) {
+                throw new Error('wcctools: the dev server was stopped while starting.');
+            }
+            return address;
         }
         catch (error) {
+            // A start that failed halfway releases what it opened
             await this.stop();
             throw error;
         }
-        const boundPort = typedServer.listeningPort ?? port;
-        return { port: boundPort, url: `http://localhost:${boundPort}${shellPathPrefix}/` };
+        finally {
+            if (this.starting === starting) {
+                this.starting = null;
+            }
+        }
     }
-    /** Stops the server, then tswatch's bundling and watching. */
-    async stop() {
+    /**
+     * Stops the server and tswatch's bundling and watching, and releases everything start()
+     * registered. A stop during start() waits for the start to settle first; concurrent and
+     * repeated calls share one stop.
+     */
+    stop() {
+        this.stopping ??= this.release().finally(() => {
+            this.stopping = null;
+        });
+        return this.stopping;
+    }
+    async release() {
+        await this.starting?.catch(() => undefined);
+        const smartExit = this.smartExit;
         const typedServer = this.typedServer;
-        const tsWatch = this.tsWatch;
+        const unsubscribeBundleEvents = this.unsubscribeBundleEvents;
+        this.smartExit = null;
         this.typedServer = null;
-        this.tsWatch = null;
-        this.smartExit.deregister();
-        await typedServer?.stop();
-        await tsWatch?.stop();
+        this.unsubscribeBundleEvents = null;
+        smartExit?.deregister();
+        // Status requests waiting for a change are refused now, so none holds the server's stop, and
+        // requests until the server stops listening are refused too: the shell backs off
+        this.api.bundleStatus.close();
+        try {
+            await typedServer?.stop();
+        }
+        finally {
+            try {
+                await this.tsWatch.stop();
+            }
+            finally {
+                unsubscribeBundleEvents?.();
+                this.running = false;
+            }
+        }
+    }
+    async startServing() {
+        const serveDir = plugins.path.resolve(this.cwd, this.config.server?.serveDir ?? defaultServeDir);
+        const port = this.options.port ?? this.config.server?.port ?? defaultPort;
+        // The preview surface watches the serve directory, which must exist before the first bundle
+        await plugins.fs.mkdir(serveDir, { recursive: true });
+        this.api.setServerInfo({
+            wcctoolsVersion: commitinfo.version,
+            projectName: await this.readProjectName(),
+        });
+        const surfaces = [await this.createShellSurface(), this.createPreviewSurface(serveDir)];
+        const typedServer = new plugins.typedserver.TypedServer({ cors: false, port, surfaces });
+        this.typedServer = typedServer;
+        this.api.bundleStatus.open();
+        const bundleStatus = this.api.bundleStatus;
+        this.unsubscribeBundleEvents = this.tsWatch.onBundleEvent((eventArg) => bundleStatus.record(eventArg));
+        // The initial bundles run here; a failed one is reported in the bundle status
+        await this.tsWatch.start();
+        await typedServer.start();
+        const boundPort = typedServer.listeningPort ?? port;
+        return { port: boundPort, url: `http://localhost:${boundPort}${shellPathPrefix}/` };
+    }
+    getElementPreset(configHandlerArg) {
+        const preset = configHandlerArg.getPreset('element');
+        if (!preset) {
+            throw new Error('wcctools: tswatch provides no `element` preset.');
+        }
+        return preset;
     }
     /**
      * The shell: the prebuilt shell bundle and the typed API.
      *
      * Seam for side-effecting APIs (assistant, capture, standards fixes): before any handler with
-     * side effects is registered here, add a `websocketAdmission`/`requestAdmission` that accepts
-     * only the shell's own origin, and keep surface mode's strict authority validation.
+     * side effects is registered here, the server binds to localhost by default (another interface
+     * only on explicit request), validates the Host header against the addresses it serves instead
+     * of accepting any hostname, and admits typedsocket connections and typed requests only from the
+     * shell's own origin (a `websocketAdmission`/`requestAdmission`), keeping surface mode's strict
+     * authority validation. Until then every handler here is read-only.
      */
     async createShellSurface() {
         return {
@@ -134,9 +208,9 @@ export class WccDevServer {
             securityHeaders,
         };
     }
-    async readProjectName(cwdArg) {
-        const packageJson = JSON.parse(await plugins.fs.readFile(plugins.path.join(cwdArg, 'package.json'), 'utf8'));
-        return packageJson.name ?? plugins.path.basename(cwdArg);
+    async readProjectName() {
+        const packageJson = JSON.parse(await plugins.fs.readFile(plugins.path.join(this.cwd, 'package.json'), 'utf8'));
+        return packageJson.name ?? plugins.path.basename(this.cwd);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/cli.js

@@ -21,7 +21,10 @@ export const registerCommands = (out) => {
             },
         },
     }, async ({ options }) => {
-        const devServer = new WccDevServer({ port: options.port });
+        const devServer = new WccDevServer({ port: options.port, cwd: process.cwd() });
+        // The entry point owns process signals: SIGINT and SIGTERM run every registered cleanup, the
+        // dev server's stop among them, once within tswatch's shutdown deadline, then exit.
+        plugins.smartexit.ProcessLifecycle.install({ shutdownTimeoutMs: devServer.getShutdownTimeoutMs() });
         const address = await devServer.start();
         await out.log(`wcctools dev: ${address.url}`);
     });
@@ -48,4 +51,4 @@ export const runCli = async () => {
         await out.dispose();
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -1,3 +1 @@
 export { runCli } from './cli.js';
-export { WccDevServer, type IWccDevServerOptions, type IWccDevServerAddress } from './classes.devserver.js';
-export { WccDevApi } from './classes.devapi.js';

package/dist_ts/index.js

@@ -1,4 +1,2 @@
 export { runCli } from './cli.js';
-export { WccDevServer } from './classes.devserver.js';
-export { WccDevApi } from './classes.devapi.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ2xDLE9BQU8sRUFBRSxZQUFZLEVBQXdELE1BQU0sd0JBQXdCLENBQUM7QUFDNUcsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFCQUFxQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sVUFBVSxDQUFDIn0=

package/dist_ts_interfaces/requests.d.ts

@@ -13,3 +13,38 @@ export interface IReq_GetDevServerInfo extends plugins.typedrequestInterfaces.im
     request: {};
     response: IWccDevServerInfo;
 }
+/** The state of a catalog bundle: its latest run started, finished or failed. */
+export type TWccBundleState = 'started' | 'finished' | 'failed';
+/** The status of one catalog bundle the dev server builds with tswatch. */
+export interface IWccBundleStatus {
+    /** The bundle's name in the tswatch configuration. */
+    name: string;
+    /** The latest run: `started` while it runs, then `finished` or `failed`. */
+    state: TWccBundleState;
+    /** Milliseconds the latest completed run took; absent before a run completed. */
+    durationMs?: number;
+    /**
+     * The bundler's error message when the latest completed run failed. It stays while the next
+     * run is in progress, so a failure is reported until a run finishes.
+     */
+    errorMessage?: string;
+}
+/** The status of every catalog bundle, at a revision that changes with every bundle event. */
+export interface IWccBundleStatusSnapshot {
+    revision: number;
+    bundles: IWccBundleStatus[];
+}
+/**
+ * Reads the bundle status. With `afterRevision`, the server answers once the status differs from
+ * that revision, or with the unchanged status after its wait limit, so a client follows the
+ * status with one request at a time. While the server is not serving (it is stopping), the request
+ * is refused with a typed error.
+ */
+export interface IReq_GetBundleStatus extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_GetBundleStatus> {
+    method: 'getBundleStatus';
+    request: {
+        /** The revision the client knows; omitted: answer at once. */
+        afterRevision?: number;
+    };
+    response: IWccBundleStatusSnapshot;
+}

package/dist_ts_shell/bundlestatus.d.ts

@@ -0,0 +1,15 @@
+import * as plugins from './plugins.js';
+/**
+ * Follows the dev server's bundle status: one `getBundleStatus` request at a time, each answered
+ * when the status changes. A failed request (the server restarting, for example) is sent again
+ * after a growing pause. `dispose()` aborts the request in flight and ends the loop.
+ */
+export declare class WccBundleStatusClient {
+    private readonly apiPath;
+    private readonly onStatus;
+    private abortController;
+    constructor(apiPath: string, onStatus: (snapshotArg: plugins.interfaces.IWccBundleStatusSnapshot) => void);
+    start(): void;
+    dispose(): void;
+    private follow;
+}

package/dist_ts_shell/bundlestatus.js

@@ -0,0 +1,64 @@
+import * as plugins from './plugins.js';
+/** The first and the longest pause before a failed status request is sent again. */
+const retryDelayMinMs = 1_000;
+const retryDelayMaxMs = 10_000;
+/** Resolves after `msArg`, or at once when the signal aborts. */
+const pause = (msArg, signalArg) => new Promise((resolve) => {
+    const done = () => {
+        clearTimeout(timer);
+        signalArg.removeEventListener('abort', done);
+        resolve();
+    };
+    const timer = setTimeout(done, msArg);
+    signalArg.addEventListener('abort', done, { once: true });
+});
+/**
+ * Follows the dev server's bundle status: one `getBundleStatus` request at a time, each answered
+ * when the status changes. A failed request (the server restarting, for example) is sent again
+ * after a growing pause. `dispose()` aborts the request in flight and ends the loop.
+ */
+export class WccBundleStatusClient {
+    apiPath;
+    onStatus;
+    abortController = null;
+    constructor(apiPath, onStatus) {
+        this.apiPath = apiPath;
+        this.onStatus = onStatus;
+    }
+    start() {
+        if (this.abortController) {
+            return;
+        }
+        const abortController = new AbortController();
+        this.abortController = abortController;
+        void this.follow(abortController.signal);
+    }
+    dispose() {
+        this.abortController?.abort();
+        this.abortController = null;
+    }
+    async follow(signalArg) {
+        const request = new plugins.typedrequest.TypedRequest(this.apiPath, 'getBundleStatus');
+        let revision;
+        let retryDelay = retryDelayMinMs;
+        while (!signalArg.aborted) {
+            try {
+                const snapshot = await request.fire({ afterRevision: revision }, { abortSignal: signalArg });
+                retryDelay = retryDelayMinMs;
+                if (!signalArg.aborted && snapshot.revision !== revision) {
+                    revision = snapshot.revision;
+                    this.onStatus(snapshot);
+                }
+            }
+            catch (error) {
+                if (signalArg.aborted) {
+                    return;
+                }
+                console.warn('wcctools: reading the bundle status failed; retrying', error);
+                await pause(retryDelay, signalArg);
+                retryDelay = Math.min(retryDelay * 2, retryDelayMaxMs);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_shell/elements/wcc-contextmenu.d.ts

@@ -25,10 +25,13 @@ export declare class WccContextmenu extends DeesElement {
     accessor visible: boolean;
     private boundHandleOutsideClick;
     private boundHandleKeydown;
+    /** The pending frame that adds the document listeners; cancelled on removal */
+    private listenerFrame;
     static styles: import("@design.estate/dees-element").CSSResult[];
     render(): TemplateResult;
     connectedCallback(): Promise<void>;
     disconnectedCallback(): Promise<void>;
+    private cancelListenerFrame;
     private adjustPosition;
     private handleOutsideClick;
     private handleKeydown;

package/dist_ts_shell/elements/wcc-contextmenu.js

@@ -108,6 +108,8 @@ let WccContextmenu = (() => {
         set visible(value) { this.#visible_accessor_storage = value; }
         boundHandleOutsideClick = (__runInitializers(this, _visible_extraInitializers), this.handleOutsideClick.bind(this));
         boundHandleKeydown = this.handleKeydown.bind(this);
+        /** The pending frame that adds the document listeners; cancelled on removal */
+        listenerFrame = null;
         static styles = [
             css `
       :host {
@@ -212,8 +214,13 @@ let WccContextmenu = (() => {
         }
         async connectedCallback() {
             await super.connectedCallback();
+            // Removed again while connecting: there is nothing to listen for
+            if (!this.isConnected)
+                return;
             // Delay adding listeners to avoid immediate close
-            requestAnimationFrame(() => {
+            this.cancelListenerFrame();
+            this.listenerFrame = requestAnimationFrame(() => {
+                this.listenerFrame = null;
                 document.addEventListener('click', this.boundHandleOutsideClick);
                 document.addEventListener('contextmenu', this.boundHandleOutsideClick);
                 document.addEventListener('keydown', this.boundHandleKeydown);
@@ -221,10 +228,18 @@ let WccContextmenu = (() => {
             });
         }
         async disconnectedCallback() {
-            await super.disconnectedCallback();
+            // A frame still pending would add the listeners after removal
+            this.cancelListenerFrame();
             document.removeEventListener('click', this.boundHandleOutsideClick);
             document.removeEventListener('contextmenu', this.boundHandleOutsideClick);
             document.removeEventListener('keydown', this.boundHandleKeydown);
+            await super.disconnectedCallback();
+        }
+        cancelListenerFrame() {
+            if (this.listenerFrame !== null) {
+                cancelAnimationFrame(this.listenerFrame);
+                this.listenerFrame = null;
+            }
         }
         adjustPosition() {
             const rect = this.getBoundingClientRect();
@@ -326,4 +341,4 @@ let WccContextmenu = (() => {
     return WccContextmenu = _classThis;
 })();
 export { WccContextmenu };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wcc-contextmenu.js","sourceRoot":"","sources":["../../../ts_shell/elements/wcc-contextmenu.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,aAAa,EAAuB,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;IAezH,cAAc;4BAD1B,aAAa,CAAC,iBAAiB,CAAC;;;;sBACG,WAAW;;;;;;;;;;;;;8BAAnB,SAAQ,WAAW;;;;qCAsC5C,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;6BAGzB,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;6BAG1B,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;mCAG1B,KAAK,EAAE;YARR,gLAAS,SAAS,6BAAT,SAAS,6FAA0B;YAG5C,wJAAS,CAAC,6BAAD,CAAC,6EAAa;YAGvB,wJAAS,CAAC,6BAAD,CAAC,6EAAa;YAGvB,0KAAS,OAAO,6BAAP,OAAO,yFAAkB;YAhDpC,6KAmRC;;;;QAlRC;;;;WAIG;QACI,MAAM,CAAC,KAAK,CAAC,IAAI,CACtB,KAAiB,EACjB,SAA6B,EAC7B,UAA+B,EAAE;YAEjC,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,KAAK,CAAC,eAAe,EAAE,CAAC;YAExB,mCAAmC;YACnC,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC;YAC3D,IAAI,QAAQ,EAAE,CAAC;gBACb,QAAQ,CAAC,MAAM,EAAE,CAAC;YACpB,CAAC;YAED,MAAM,IAAI,GAAG,IAAI,cAAc,EAAE,CAAC;YAClC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;YAC3B,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC;YACvB,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC;YACvB,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,IAAI,IAAI,CAAC;YAEjD,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAEhC,iDAAiD;YACjD,MAAM,IAAI,CAAC,cAAc,CAAC;YAC1B,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QACpB,CAAC;QAED,mFAAmF;QAC3E,YAAY,GAAuB,IAAI,CAAC;QACxC,OAAO,GAAG,KAAK,CAAC;QAGxB,+EAAyC,EAAE,EAAC;QAA5C,IAAS,SAAS,+CAA0B;QAA5C,IAAS,SAAS,qDAA0B;QAG5C,uHAAqB,CAAC,GAAC;QAAvB,IAAS,CAAC,uCAAa;QAAvB,IAAS,CAAC,6CAAa;QAGvB,+GAAqB,CAAC,GAAC;QAAvB,IAAS,CAAC,uCAAa;QAAvB,IAAS,CAAC,6CAAa;QAGvB,2HAA4B,KAAK,GAAC;QAAlC,IAAS,OAAO,6CAAkB;QAAlC,IAAS,OAAO,mDAAkB;QAE1B,uBAAuB,yDAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAC;QAC7D,kBAAkB,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEpD,MAAM,CAAC,MAAM,GAAG;YACrB,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiFF;SACF,CAAC;QAEK,MAAM;YACX,OAAO,IAAI,CAAA;6DAC8C,IAAI,CAAC,iBAAiB;UACzE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAA;;+BAEV,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE;;;4BAGlC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO;qBACvC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;;cAEvC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAA,yCAAyC,IAAI,CAAC,QAAQ,SAAS,CAAC,CAAC,CAAC,IAAI;kCACtE,IAAI,CAAC,IAAI;;SAElC,CAAC;;KAEL,CAAC;QACJ,CAAC;QAED,KAAK,CAAC,iBAAiB;YACrB,MAAM,KAAK,CAAC,iBAAiB,EAAE,CAAC;YAChC,kDAAkD;YAClD,qBAAqB,CAAC,GAAG,EAAE;gBACzB,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,uBAAuB,CAAC,CAAC;gBACjE,QAAQ,CAAC,gBAAgB,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,CAAC,CAAC;gBACvE,QAAQ,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;gBAC9D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAChC,CAAC,CAAC,CAAC;QACL,CAAC;QAED,KAAK,CAAC,oBAAoB;YACxB,MAAM,KAAK,CAAC,oBAAoB,EAAE,CAAC;YACnC,QAAQ,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,uBAAuB,CAAC,CAAC;YACpE,QAAQ,CAAC,mBAAmB,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,CAAC,CAAC;YAC1E,QAAQ,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACnE,CAAC;QAEO,cAAc;YACpB,MAAM,IAAI,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC1C,MAAM,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC;YACtC,MAAM,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC;YAExC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;YACf,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;YAEf,qCAAqC;YACrC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,GAAG,WAAW,GAAG,EAAE,EAAE,CAAC;gBACtC,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;YACpC,CAAC;YAED,sCAAsC;YACtC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,YAAY,GAAG,EAAE,EAAE,CAAC;gBACxC,CAAC,GAAG,YAAY,GAAG,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;YACtC,CAAC;YAED,6BAA6B;YAC7B,IAAI,CAAC,GAAG,EAAE;gBAAE,CAAC,GAAG,EAAE,CAAC;YACnB,IAAI,CAAC,GAAG,EAAE;gBAAE,CAAC,GAAG,EAAE,CAAC;YAEnB,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;YAC3B,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC;QAC5B,CAAC;QAEO,kBAAkB,CAAC,CAAQ;YACjC,MAAM,IAAI,GAAG,CAAC,CAAC,YAAY,EAAE,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBACzB,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,CAAC;QACH,CAAC;QAEO,aAAa,CAAC,CAAgB;YACpC,IAAI,CAAC,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;gBACvB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACnB,CAAC;QACH,CAAC;QAEO,eAAe;YACrB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,gBAAgB,CAAc,2BAA2B,CAAC,IAAI,EAAE,CAAC,CAAC;QACvG,CAAC;QAED,kFAAkF;QAC1E,SAAS,CAAC,QAAgB;YAChC,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;YACrC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACtB,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,OAAO,CAAwB,EAAE,KAAK,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;gBAChG,OAAO;YACT,CAAC;YACD,MAAM,KAAK,GAAG,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;YACxE,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QAC9C,CAAC;QAEO,iBAAiB,GAAG,CAAC,CAAgB,EAAE,EAAE;YAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;YACrC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,aAA4B,CAAC,CAAC;YAC7E,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC;gBACd,KAAK,WAAW;oBACd,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;oBAC5B,MAAM;gBACR,KAAK,SAAS;oBACZ,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;oBAC/C,MAAM;gBACR,KAAK,MAAM;oBACT,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;oBAClB,MAAM;gBACR,KAAK,KAAK;oBACR,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;oBACnB,MAAM;gBACR,KAAK,OAAO,CAAC;gBACb,KAAK,GAAG;oBACN,IAAI,OAAO,IAAI,CAAC;wBAAE,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,CAAC;oBACzC,MAAM;gBACR,KAAK,QAAQ,CAAC;gBACd,KAAK,KAAK;oBACR,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;oBACjB,MAAM;gBACR;oBACE,OAAO;YACX,CAAC;YACD,CAAC,CAAC,cAAc,EAAE,CAAC;YACnB,CAAC,CAAC,eAAe,EAAE,CAAC;QACtB,CAAC,CAAC;QAEM,KAAK,CAAC,eAAe,CAAC,IAAsB;YAClD,IAAI,IAAI,CAAC,QAAQ;gBAAE,OAAO;YAC1B,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;YACpB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACnB,CAAC;QAEO,KAAK,CAAC,WAAW,GAAG,KAAK;YAC/B,IAAI,IAAI,CAAC,OAAO;gBAAE,OAAO;YACzB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,WAAW,IAAI,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,CAAC;gBAClD,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;YACnD,CAAC;YACD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACjC,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,GAAG,CAAC,CAAC;QACvC,CAAC;;YAlRU,uDAAc;;;;;SAAd,cAAc"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wcc-contextmenu.js","sourceRoot":"","sources":["../../../ts_shell/elements/wcc-contextmenu.ts"],"names":[],"mappings":"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"}

package/dist_ts_shell/elements/wcc-preview-frame.d.ts

@@ -1,4 +1,5 @@
 import { DeesElement, type TemplateResult } from '@design.estate/dees-element';
+import * as plugins from '../plugins.js';
 export type TWccViewport = 'native' | 'desktop' | 'tablet' | 'phablet' | 'phone';
 declare global {
     interface HTMLElementTagNameMap {
@@ -17,6 +18,11 @@ export declare class WccPreviewFrame extends DeesElement {
     accessor isNative: boolean;
     accessor sidebarWidth: number;
     accessor isResizing: boolean;
+    /**
+     * Catalog bundles whose latest run failed: shown over the preview, which shows an outdated
+     * bundle or none, until a run finishes and the preview reloads.
+     */
+    accessor bundleFailures: plugins.interfaces.IWccBundleStatus[];
     static styles: import("@design.estate/dees-element").CSSResult[];
     get iframe(): HTMLIFrameElement | null;
     render(): TemplateResult;