@design.estate/wcctools 5.1.0 → 6.1.0

package/dist_shell/index.html

@@ -0,0 +1,21 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>wcctools</title>
+    <link rel="icon" href="data:," />
+    <link rel="preconnect" href="https://assetbroker.lossless.one/" crossorigin>
+    <link rel="stylesheet" href="https://assetbroker.lossless.one/fonts/fonts.css">
+    <style>
+      body {
+        margin: 0px;
+        background: #0a0a0a;
+      }
+    </style>
+    <script type="module" src="/wcctools/bundle.js"></script>
+  </head>
+  <body>
+    <wcc-shell preview-path="/wcctools-preview"></wcc-shell>
+  </body>
+</html>

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@design.estate/wcctools',
+    version: '6.1.0',
+    description: 'A set of web component tools for creating element catalogues, enabling the structured development and documentation of custom elements and pages.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLG1KQUFtSjtDQUNqSyxDQUFBIn0=

package/dist_ts/classes.devapi.d.ts

@@ -0,0 +1,11 @@
+import * as plugins from './plugins.js';
+/**
+ * The typed API the shell reaches on `/wcctools/typedrequest`. Later features register their
+ * handlers on `typedrouter`.
+ */
+export declare class WccDevApi {
+    readonly typedrouter: plugins.typedrequest.TypedRouter<import("@api.global/typedrequest-interfaces").ITypedRequest>;
+    private serverInfo;
+    constructor();
+    setServerInfo(infoArg: plugins.interfaces.IWccDevServerInfo): void;
+}

package/dist_ts/classes.devapi.js

@@ -0,0 +1,21 @@
+import * as plugins from './plugins.js';
+/**
+ * The typed API the shell reaches on `/wcctools/typedrequest`. Later features register their
+ * handlers on `typedrouter`.
+ */
+export class WccDevApi {
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    serverInfo = null;
+    constructor() {
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getDevServerInfo', async () => {
+            if (!this.serverInfo) {
+                throw new Error('The dev server has not started.');
+            }
+            return { ...this.serverInfo };
+        }));
+    }
+    setServerInfo(infoArg) {
+        this.serverInfo = { ...infoArg };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5kZXZhcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jbGFzc2VzLmRldmFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4Qzs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sU0FBUztJQUNKLFdBQVcsR0FBRyxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDN0QsVUFBVSxHQUFnRCxJQUFJLENBQUM7SUFFdkU7UUFDRSxJQUFJLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FDOUIsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBMkMsa0JBQWtCLEVBQUUsS0FBSyxJQUFJLEVBQUU7WUFDN0csSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDckIsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO1lBQ3JELENBQUM7WUFDRCxPQUFPLEVBQUUsR0FBRyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDaEMsQ0FBQyxDQUFDLENBQ0gsQ0FBQztJQUNKLENBQUM7SUFFTSxhQUFhLENBQUMsT0FBNkM7UUFDaEUsSUFBSSxDQUFDLFVBQVUsR0FBRyxFQUFFLEdBQUcsT0FBTyxFQUFFLENBQUM7SUFDbkMsQ0FBQztDQUNGIn0=

package/dist_ts/classes.devserver.d.ts

@@ -0,0 +1,49 @@
+import { WccDevApi } from './classes.devapi.js';
+export interface IWccDevServerOptions {
+    /** Port to listen on; overrides the tswatch configuration. 0 picks a free port. */
+    port?: number;
+}
+export interface IWccDevServerAddress {
+    port: number;
+    /** The shell's address. */
+    url: string;
+}
+/**
+ * `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:
+ *
+ * - the shell on `/wcctools/` (`/` redirects there) and its routes `/wcctools-route/...`,
+ * - the typed API on `/wcctools/typedrequest`,
+ * - 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.
+ */
+export declare class WccDevServer {
+    private readonly options;
+    /** The typed API on `/wcctools/typedrequest`; register further handlers before `start()`. */
+    readonly api: WccDevApi;
+    private tsWatch;
+    private typedServer;
+    private readonly smartExit;
+    constructor(options?: IWccDevServerOptions);
+    start(): Promise<IWccDevServerAddress>;
+    /** Stops the server, then tswatch's bundling and watching. */
+    stop(): Promise<void>;
+    /**
+     * 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.
+     */
+    private createShellSurface;
+    /**
+     * The preview: the catalog's own document and bundle from the tswatch serve directory, on
+     * the root paths it was written for. Its live reload client is injected into its document
+     * only, so a rebuilt bundle reloads the preview frame and never the shell.
+     */
+    private createPreviewSurface;
+    private readProjectName;
+}

package/dist_ts/classes.devserver.js

@@ -0,0 +1,142 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+import { commitinfo } from './00_commitinfo_data.js';
+import { WccDevApi } from './classes.devapi.js';
+import { loadShellContent, shellPathPrefix } from './shellcontent.js';
+/** tswatch's default port and serve directory, used when the configuration names none. */
+const defaultPort = 3002;
+const defaultServeDir = './dist_watch/';
+/** The development headers tswatch serves catalogs with: a cross-origin isolated document. */
+const securityHeaders = {
+    crossOriginOpenerPolicy: 'same-origin',
+    crossOriginEmbedderPolicy: 'require-corp',
+};
+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:
+ *
+ * - the shell on `/wcctools/` (`/` redirects there) and its routes `/wcctools-route/...`,
+ * - the typed API on `/wcctools/typedrequest`,
+ * - 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.
+ */
+export class WccDevServer {
+    options;
+    /** The typed API on `/wcctools/typedrequest`; register further handlers before `start()`. */
+    api = new WccDevApi();
+    tsWatch = null;
+    typedServer = null;
+    smartExit = new plugins.smartexit.SmartExit({ silent: true });
+    constructor(options = {}) {
+        this.options = options;
+        this.smartExit.addCleanupFunction(() => this.stop());
+    }
+    async start() {
+        if (this.typedServer) {
+            throw new Error('wcctools: the dev server is already started.');
+        }
+        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 } });
+        try {
+            await this.tsWatch.start();
+            await typedServer.start();
+        }
+        catch (error) {
+            await this.stop();
+            throw error;
+        }
+        const boundPort = typedServer.listeningPort ?? port;
+        return { port: boundPort, url: `http://localhost:${boundPort}${shellPathPrefix}/` };
+    }
+    /** Stops the server, then tswatch's bundling and watching. */
+    async stop() {
+        const typedServer = this.typedServer;
+        const tsWatch = this.tsWatch;
+        this.typedServer = null;
+        this.tsWatch = null;
+        this.smartExit.deregister();
+        await typedServer?.stop();
+        await tsWatch?.stop();
+    }
+    /**
+     * 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.
+     */
+    async createShellSurface() {
+        return {
+            name: 'shell',
+            match: {
+                hostnameResolver: acceptAnyHostname,
+                pathPrefixes: [shellPathPrefix, '/wcctools-route'],
+            },
+            bundledContent: await loadShellContent(paths.distShellDir),
+            spaFallback: true,
+            httpTypedRouter: this.api.typedrouter,
+            typedRequestPath: `${shellPathPrefix}/typedrequest`,
+            noCache: true,
+            securityHeaders,
+        };
+    }
+    /**
+     * The preview: the catalog's own document and bundle from the tswatch serve directory, on
+     * the root paths it was written for. Its live reload client is injected into its document
+     * only, so a rebuilt bundle reloads the preview frame and never the shell.
+     */
+    createPreviewSurface(serveDirArg) {
+        return {
+            name: 'preview',
+            match: {
+                hostnameResolver: acceptAnyHostname,
+                pathPrefixes: ['/'],
+            },
+            serveDir: serveDirArg,
+            spaFallback: true,
+            injectReload: true,
+            watch: true,
+            // Lets the reload client get pushed changes instead of polling
+            websocketTypedRouter: new plugins.typedrequest.TypedRouter(),
+            // As tswatch serves catalogs
+            cors: true,
+            httpHandler: async (contextArg) => {
+                if (contextArg.path === '/' && (contextArg.method === 'GET' || contextArg.method === 'HEAD')) {
+                    return new Response(null, { status: 302, headers: { Location: `${shellPathPrefix}/` } });
+                }
+                return null;
+            },
+            noCache: true,
+            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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/cli.d.ts

@@ -0,0 +1,6 @@
+import * as plugins from './plugins.js';
+/**
+ * Registers the wcctools commands on the given console.
+ */
+export declare const registerCommands: (out: plugins.smartconsole.SmartConsole) => void;
+export declare const runCli: () => Promise<void>;

package/dist_ts/cli.js

@@ -0,0 +1,51 @@
+import * as plugins from './plugins.js';
+import { commitinfo } from './00_commitinfo_data.js';
+import { WccDevServer } from './classes.devserver.js';
+import { StandardConfigError, StandardUsageError, registerStandardCommands } from './standards/index.js';
+/**
+ * Registers the wcctools commands on the given console.
+ */
+export const registerCommands = (out) => {
+    out.cli.configure({
+        name: 'wcctools',
+        version: commitinfo.version,
+        description: 'Develop a web component catalog in the wcctools shell',
+    });
+    out.cli.command({
+        name: 'dev',
+        description: 'Bundle the catalog with live reload and serve it in the wcctools shell',
+        options: {
+            port: {
+                type: 'number',
+                description: 'Port to listen on (0 picks a free port); overrides the tswatch configuration',
+            },
+        },
+    }, async ({ options }) => {
+        const devServer = new WccDevServer({ port: options.port });
+        const address = await devServer.start();
+        await out.log(`wcctools dev: ${address.url}`);
+    });
+    registerStandardCommands(out);
+    out.cli.default({}, async () => {
+        await out.log(out.cli.renderHelp());
+    });
+};
+export const runCli = async () => {
+    const out = new plugins.smartconsole.SmartConsole();
+    try {
+        registerCommands(out);
+        await out.cli.run();
+    }
+    catch (error) {
+        await out.error(error instanceof Error ? error.message : String(error));
+        // Configuration and usage errors exit with 2, every other failure with 1.
+        const usageError = error instanceof plugins.smartconsole.CliUsageError
+            || error instanceof StandardConfigError
+            || error instanceof StandardUsageError;
+        process.exitCode = usageError ? 2 : 1;
+    }
+    finally {
+        await out.dispose();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -0,0 +1,3 @@
+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

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

package/dist_ts/paths.d.ts

@@ -0,0 +1,4 @@
+/** The root of the installed wcctools package. */
+export declare const packageDir: string;
+/** The prebuilt shell bundle the package ships. */
+export declare const distShellDir: string;

package/dist_ts/paths.js

@@ -0,0 +1,6 @@
+import * as plugins from './plugins.js';
+/** The root of the installed wcctools package. */
+export const packageDir = plugins.path.resolve(plugins.path.dirname(plugins.url.fileURLToPath(import.meta.url)), '..');
+/** The prebuilt shell bundle the package ships. */
+export const distShellDir = plugins.path.join(packageDir, 'dist_shell');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxrREFBa0Q7QUFDbEQsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQztBQUV2SCxtREFBbUQ7QUFDbkQsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxZQUFZLENBQUMsQ0FBQyJ9

package/dist_ts/plugins.d.ts

@@ -0,0 +1,20 @@
+import * as childProcess from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
+import * as path from 'node:path';
+import * as url from 'node:url';
+export { childProcess, fs, fsSync, path, url };
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedserver from '@api.global/typedserver';
+export { typedrequest, typedserver };
+import * as tswatch from '@git.zone/tswatch';
+export { tswatch };
+import * as smartconfig from '@push.rocks/smartconfig';
+import * as smartconsole from '@push.rocks/smartconsole';
+import * as smartexit from '@push.rocks/smartexit';
+export { smartconfig, smartconsole, smartexit };
+import typescript from 'typescript';
+export { typescript };
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import * as shared from '../dist_ts_shared/index.js';
+export { interfaces, shared };

package/dist_ts/plugins.js

@@ -0,0 +1,27 @@
+// node native scope
+import * as childProcess from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
+import * as path from 'node:path';
+import * as url from 'node:url';
+export { childProcess, fs, fsSync, path, url };
+// @api.global scope
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedserver from '@api.global/typedserver';
+export { typedrequest, typedserver };
+// @git.zone scope
+import * as tswatch from '@git.zone/tswatch';
+export { tswatch };
+// @push.rocks scope
+import * as smartconfig from '@push.rocks/smartconfig';
+import * as smartconsole from '@push.rocks/smartconsole';
+import * as smartexit from '@push.rocks/smartexit';
+export { smartconfig, smartconsole, smartexit };
+// third party scope
+import typescript from 'typescript';
+export { typescript };
+// project scope
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import * as shared from '../dist_ts_shared/index.js';
+export { interfaces, shared };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssTUFBTSxNQUFNLFNBQVMsQ0FBQztBQUNsQyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssR0FBRyxNQUFNLFVBQVUsQ0FBQztBQUVoQyxPQUFPLEVBQUUsWUFBWSxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxDQUFDO0FBRS9DLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFFdkQsT0FBTyxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsQ0FBQztBQUVyQyxrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxtQkFBbUIsQ0FBQztBQUU3QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxDQUFDO0FBRWhELG9CQUFvQjtBQUNwQixPQUFPLFVBQVUsTUFBTSxZQUFZLENBQUM7QUFFcEMsT0FBTyxFQUFFLFVBQVUsRUFBRSxDQUFDO0FBRXRCLGdCQUFnQjtBQUNoQixPQUFPLEtBQUssVUFBVSxNQUFNLDJCQUEyQixDQUFDO0FBQ3hELE9BQU8sS0FBSyxNQUFNLE1BQU0sdUJBQXVCLENBQUM7QUFFaEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsQ0FBQyJ9

package/dist_ts/shellcontent.d.ts

@@ -0,0 +1,9 @@
+import * as plugins from './plugins.js';
+/** The path below which the shell surface serves the shell bundle. */
+export declare const shellPathPrefix = "/wcctools";
+/**
+ * The prebuilt shell bundle as in-memory content of the shell surface. A surface serves files
+ * by their full request path, so every file is keyed below `wcctools/`; the shell page is
+ * also keyed as `index.html`, which the surface's SPA fallback answers `/wcctools-route/...` with.
+ */
+export declare const loadShellContent: (distShellDirArg: string) => Promise<plugins.typedserver.IBundledContentItem[]>;

package/dist_ts/shellcontent.js

@@ -0,0 +1,42 @@
+import * as plugins from './plugins.js';
+/** The path below which the shell surface serves the shell bundle. */
+export const shellPathPrefix = '/wcctools';
+const collectFiles = async (dirArg, relativeDirArg = '') => {
+    const entries = await plugins.fs.readdir(plugins.path.join(dirArg, relativeDirArg), { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const relativePath = relativeDirArg ? `${relativeDirArg}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            files.push(...await collectFiles(dirArg, relativePath));
+        }
+        else if (entry.isFile()) {
+            files.push(relativePath);
+        }
+    }
+    return files;
+};
+/**
+ * The prebuilt shell bundle as in-memory content of the shell surface. A surface serves files
+ * by their full request path, so every file is keyed below `wcctools/`; the shell page is
+ * also keyed as `index.html`, which the surface's SPA fallback answers `/wcctools-route/...` with.
+ */
+export const loadShellContent = async (distShellDirArg) => {
+    const indexPath = plugins.path.join(distShellDirArg, 'index.html');
+    try {
+        await plugins.fs.access(indexPath);
+    }
+    catch {
+        throw new Error(`wcctools: the shell bundle is missing (${indexPath}); build the package with "pnpm build".`);
+    }
+    const prefix = shellPathPrefix.slice(1);
+    const content = [];
+    for (const relativePath of await collectFiles(distShellDirArg)) {
+        const contentBase64 = (await plugins.fs.readFile(plugins.path.join(distShellDirArg, relativePath))).toString('base64');
+        content.push({ path: `${prefix}/${relativePath}`, contentBase64 });
+        if (relativePath === 'index.html') {
+            content.push({ path: 'index.html', contentBase64 });
+        }
+    }
+    return content;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/baselines.d.ts

@@ -0,0 +1,27 @@
+import * as plugins from '../plugins.js';
+type IStandardConfig = plugins.interfaces.IStandardConfig;
+type IStandardReport = plugins.interfaces.IStandardReport;
+type TBaselines = NonNullable<IStandardConfig['baselines']>;
+/** `--init-baseline`: the current error counts of every rule. Only valid while the configuration has no baselines. */
+export declare const initialBaselines: (reportArg: IStandardReport) => TBaselines;
+export interface IBaselineRaise {
+    ruleId: string;
+    file: string;
+    baseline: number;
+    current: number;
+}
+/**
+ * `--update-baseline`: lowers every count to the current one and removes entries that reach 0.
+ * `raised` lists every file whose count would have to grow, including files without an entry;
+ * when it is not empty the update is refused.
+ */
+export declare const updatedBaselines: (reportArg: IStandardReport, baselinesArg: TBaselines) => {
+    baselines: TBaselines;
+    raised: IBaselineRaise[];
+};
+/** The configuration with allowlist and baseline file paths moved along with `wcctools fix` moves. */
+export declare const rekeyStandardConfig: (configArg: IStandardConfig, movesArg: readonly plugins.interfaces.IStandardFileMove[]) => {
+    config: IStandardConfig;
+    changed: string[];
+};
+export {};

package/dist_ts/standards/baselines.js

@@ -0,0 +1,83 @@
+import * as plugins from '../plugins.js';
+import { allowlistStaleRuleId } from './rules/index.js';
+/**
+ * Baseline arithmetic of the ratchet. Pure functions: persisting the result goes through
+ * IStandardConfigWriter (see config.ts).
+ */
+/** Per rule and file, the error findings a baseline would have to accept (allowlisted findings excluded). */
+const errorCounts = (reportArg) => {
+    const counts = {};
+    for (const finding of reportArg.findings) {
+        if (finding.severity !== 'error' || finding.covered === 'allowlist' || finding.ruleId === allowlistStaleRuleId) {
+            continue;
+        }
+        counts[finding.ruleId] ??= {};
+        counts[finding.ruleId][finding.file] = (counts[finding.ruleId][finding.file] ?? 0) + 1;
+    }
+    return counts;
+};
+const sortBaselines = (baselinesArg) => {
+    const sorted = {};
+    for (const ruleId of Object.keys(baselinesArg).sort()) {
+        const files = Object.keys(baselinesArg[ruleId]).sort();
+        if (files.length > 0) {
+            sorted[ruleId] = Object.fromEntries(files.map((fileArg) => [fileArg, baselinesArg[ruleId][fileArg]]));
+        }
+    }
+    return sorted;
+};
+/** `--init-baseline`: the current error counts of every rule. Only valid while the configuration has no baselines. */
+export const initialBaselines = (reportArg) => sortBaselines(errorCounts(reportArg));
+/**
+ * `--update-baseline`: lowers every count to the current one and removes entries that reach 0.
+ * `raised` lists every file whose count would have to grow, including files without an entry;
+ * when it is not empty the update is refused.
+ */
+export const updatedBaselines = (reportArg, baselinesArg) => {
+    const current = errorCounts(reportArg);
+    const raised = [];
+    const baselines = {};
+    for (const [ruleId, counts] of Object.entries(baselinesArg)) {
+        baselines[ruleId] = {};
+        for (const [file, baseline] of Object.entries(counts)) {
+            const count = current[ruleId]?.[file] ?? 0;
+            if (count > baseline) {
+                raised.push({ ruleId, file, baseline, current: count });
+            }
+            else if (count > 0) {
+                baselines[ruleId][file] = count;
+            }
+        }
+    }
+    for (const [ruleId, counts] of Object.entries(current)) {
+        for (const [file, count] of Object.entries(counts)) {
+            if (baselinesArg[ruleId]?.[file] === undefined) {
+                raised.push({ ruleId, file, baseline: 0, current: count });
+            }
+        }
+    }
+    return { baselines: sortBaselines(baselines), raised };
+};
+/** The configuration with allowlist and baseline file paths moved along with `wcctools fix` moves. */
+export const rekeyStandardConfig = (configArg, movesArg) => {
+    const moved = new Map(movesArg.map((moveArg) => [moveArg.from, moveArg.to]));
+    const changed = [];
+    const rekey = (keyArg) => {
+        const [file, ...member] = keyArg.split('#');
+        const target = moved.get(file);
+        if (!target) {
+            return keyArg;
+        }
+        changed.push(keyArg);
+        return [target, ...member].join('#');
+    };
+    const config = { ...configArg };
+    if (configArg.allowlist) {
+        config.allowlist = Object.fromEntries(Object.entries(configArg.allowlist).map(([ruleId, entries]) => [ruleId, Object.fromEntries(Object.entries(entries).map(([key, value]) => [rekey(key), value]))]));
+    }
+    if (configArg.baselines) {
+        config.baselines = Object.fromEntries(Object.entries(configArg.baselines).map(([ruleId, counts]) => [ruleId, Object.fromEntries(Object.entries(counts).map(([file, count]) => [rekey(file), count]))]));
+    }
+    return { config, changed };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/checker.d.ts

@@ -0,0 +1,21 @@
+import * as plugins from '../plugins.js';
+import type { StandardProject } from './classes.standardproject.js';
+import type { ILoadedStandardConfig } from './config.js';
+import { type IRuleFinding, type IStandardRule } from './rule.js';
+type IStandardReport = plugins.interfaces.IStandardReport;
+type TStandardProfile = plugins.interfaces.TStandardProfile;
+/** The rules of a profile, in the order of docs/standard.md. */
+export declare const rulesOfProfile: (profileArg: TStandardProfile) => IStandardRule[];
+/** The rules of a profile as the shell and the AI agent see them. */
+export declare const describeStandardRules: (profileArg: TStandardProfile) => plugins.interfaces.IStandardRuleInfo[];
+/** A finding of one rule with its allowlist state. */
+export interface IDetectedFinding {
+    rule: IStandardRule;
+    finding: IRuleFinding;
+    allowlisted: boolean;
+}
+/** Runs the rules of the configured profile; findings carry their fix actions. */
+export declare const detectFindings: (projectArg: StandardProject, loadedArg: ILoadedStandardConfig, rulesArg?: readonly IStandardRule[]) => IDetectedFinding[];
+/** Checks a repository against the standard: findings, allowlist, baselines. */
+export declare const checkStandard: (projectArg: StandardProject, loadedArg: ILoadedStandardConfig) => IStandardReport;
+export {};