@kernhq/module-quire 0.13.1 → 0.15.0

package/dist/server/_impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_impl.d.ts","sourceRoot":"","sources":["../../src/server/_impl.ts"],"names":[],"mappings":"AACA,OAAO,EACL,YAAY,EACZ,kBAAkB,EAElB,KAAK,MAAM,EAEX,cAAc,EACd,KAAK,cAAc,EAIpB,MAAM,gBAAgB,CAAA;AAWvB;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAA;AAqF3D,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2uCxC"}
+{"version":3,"file":"_impl.d.ts","sourceRoot":"","sources":["../../src/server/_impl.ts"],"names":[],"mappings":"AACA,OAAO,EACL,YAAY,EACZ,kBAAkB,EAElB,KAAK,MAAM,EAEX,cAAc,EACd,KAAK,cAAc,EAIpB,MAAM,gBAAgB,CAAA;AAYvB;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAA;AAqF3D,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2oDxC"}

package/dist/server/_impl.js

@@ -7,6 +7,7 @@ import { quireServices, resolveWorkspaceSegment } from './services/index.js';
 import { createNotify } from './services/notify.js';
 import { documentNameOf, toPage } from './services/pages.js';
 import { toPublication } from './services/publications.js';
+import { toTemplate } from './services/templates.js';
 import { toVersion } from './services/versions.js';
 /**
  * The router, kept apart from `index.ts` so `module.test.ts` can walk it without booting a kernel.
@@ -154,6 +155,19 @@ export function implement_(kernel) {
     };
     /** Both, every time: the event for anything that reacts later, the change for a screen open now. */
     const announce = (workspaceId, entity, id, op, scope) => kernel.realtime.change(workspaceId, { module: MODULE_ID, entity, id, op, scope });
+    /**
+     * The same, for the one entity a workspace-wide broadcast should not carry.
+     *
+     * A transfer is fenced to the person who asked for it everywhere else — `list` returns only their
+     * rows, `get` answers NOT_FOUND rather than FORBIDDEN for anyone else's id — and announcing it on
+     * the workspace channel handed every member the id and the moment it was created, which is the
+     * fact the NOT_FOUND exists to withhold. `services/export.ts` carries the long version.
+     */
+    const announceToRequester = (workspaceId, userId, entity, id, op) => kernel.realtime.toUser(userId, {
+        t: 'change',
+        workspaceId: workspaceId,
+        change: { module: MODULE_ID, entity, id, op },
+    });
     return os.router({
         spaces: {
             list: scoped.spaces.list
@@ -757,6 +771,300 @@ export function implement_(kernel) {
                 return { ok: true };
             })),
         },
+        /**
+         * Taking work out.
+         *
+         * The handler is deliberately thin, because nothing about an export can be decided here: which
+         * pages go in is a per-page permission question asked as the requester against a tree that may
+         * be five hundred deep, and rendering one is a round trip to storage and possibly to Chromium.
+         * All three of those outlive an HTTP request, so this records a row, hands it to a worker, and
+         * answers with something to watch.
+         *
+         * The one thing it *does* decide is whether this person may ask at all, and that is asked twice
+         * over: `requires` puts the workspace-level gate on the procedure, and the handler resolves the
+         * target — a page's own ancestor chain, or the space — and asks again at the narrow scope. The
+         * second check is the one a page-scoped DENY can reach.
+         */
+        exports: {
+            start: scoped.exports.start.use(requires('quire.page.export')).handler(async ({ input, context }) => {
+                const row = await run(context, input.workspaceId, async (tx) => {
+                    if (input.scope === 'space') {
+                        await svc.access.spaceRow(tx, input.workspaceId, input.targetId);
+                        await svc.access.requireSpace(context.principal, 'quire.page.export', input.workspaceId, input.targetId);
+                    }
+                    else {
+                        await requirePage(tx, context, input.workspaceId, input.targetId, 'quire.page.export');
+                    }
+                    // Expired artefacts go now, and jobs that lost their worker are failed now, in the
+                    // workspace whose transaction is already open — see the notes on `sweep` and `reap` for
+                    // why neither is a cron job. Neither may take a request down, hence the catch.
+                    await svc.exports.sweep(tx, input.workspaceId).catch(() => 0);
+                    await svc.exports.reap(tx, input.workspaceId).catch(() => 0);
+                    return svc.exports.start(tx, context.principal, input.workspaceId, input);
+                });
+                /*
+                 * Sent after the row is committed, so the worker cannot reach for a row that is not there
+                 * yet. If the queue refuses the job the row would otherwise sit `queued` for ever, looking
+                 * like work in progress — so it is failed here, with the reason, rather than left hanging.
+                 */
+                try {
+                    await kernel.jobs.send('quire.export', { workspaceId: input.workspaceId, jobId: row.id });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    kernel.log.error({ err: message, jobId: row.id }, 'quire: an export could not be queued');
+                    await run(context, input.workspaceId, (tx) => svc.exports.fail(tx, input.workspaceId, row.id, message));
+                    throw new KernError('UNAVAILABLE', 'The export could not be queued. Try again in a moment.');
+                }
+                await announceToRequester(input.workspaceId, row.requestedBy, 'export', row.id, 'created');
+                return { ...svc.exports.toExportJob(row), downloadUrl: null };
+            }),
+            get: scoped.exports.get.use(requires('quire.page.export')).handler(({ input, context }) => run(context, input.workspaceId, async (tx) => {
+                const row = await svc.exports.get(tx, input.workspaceId, input.jobId, context.principal);
+                return {
+                    ...svc.exports.toExportJob(row),
+                    downloadUrl: await svc.exports.downloadUrl(tx, input.workspaceId, row),
+                };
+            })),
+            list: scoped.exports.list.use(requires('quire.page.export')).handler(({ input, context }) => run(context, input.workspaceId, async (tx) => {
+                await svc.exports.sweep(tx, input.workspaceId).catch(() => 0);
+                // This list is polled every two seconds while anything on it is running, so it is the
+                // thing that ends a job whose worker went away rather than drawing its spinner for ever.
+                await svc.exports.reap(tx, input.workspaceId).catch(() => 0);
+                const rows = await svc.exports.list(tx, input.workspaceId, context.principal, input.limit);
+                return rows.map(svc.exports.toExportJob);
+            })),
+        },
+        imports: {
+            /**
+             * Queue one.
+             *
+             * The permission is checked here **and** again inside the job, and the two are not the same
+             * check. This one refuses a request before a row exists; the one in the job refuses to write
+             * after the queue has held the work for a minute, which is where a permission taken away in
+             * the meantime would otherwise be missed. `services/import.ts` does both, so the order they
+             * happen in cannot drift between the router and the worker.
+             */
+            start: scoped.imports.start.use(requires('quire.page.import')).handler(async ({ input, context }) => {
+                const row = await run(context, input.workspaceId, async (tx) => {
+                    // Jobs that lost their worker are failed now, in the workspace whose transaction is
+                    // already open — see `reap` for why this is not a cron job, and why it marks rather than
+                    // deletes. It must not take the request down, hence the catch.
+                    await svc.imports.reap(tx, input.workspaceId).catch(() => 0);
+                    return svc.imports.start(tx, context.principal, input.workspaceId, input);
+                });
+                /*
+                 * Sent after the row is committed, so the worker cannot reach for a row that is not there
+                 * yet. If the queue refuses the job the row would otherwise sit `queued` for ever, looking
+                 * like an import in progress to somebody waiting to see whether their pages arrived — so it
+                 * is failed here, with the reason, rather than left hanging.
+                 */
+                try {
+                    await kernel.jobs.send('quire.import', { workspaceId: input.workspaceId, jobId: row.id });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    kernel.log.error({ err: message, jobId: row.id }, 'quire: an import could not be queued');
+                    await run(context, input.workspaceId, (tx) => svc.imports.fail(tx, input.workspaceId, row.id, message));
+                    throw new KernError('UNAVAILABLE', 'The import could not be queued. Try again in a moment.');
+                }
+                await announceToRequester(input.workspaceId, row.requestedBy, 'import', row.id, 'created');
+                return svc.imports.toImportJob(row);
+            }),
+            get: scoped.imports.get
+                .use(requires('quire.page.import'))
+                .handler(({ input, context }) => run(context, input.workspaceId, async (tx) => svc.imports.toImportJob(await svc.imports.get(tx, input.workspaceId, input.jobId, context.principal)))),
+            /** Without the reports — a list of thousands-of-rows reports is megabytes to draw a table. */
+            list: scoped.imports.list.use(requires('quire.page.import')).handler(({ input, context }) => run(context, input.workspaceId, async (tx) => {
+                // Polled every two seconds while anything on it is running, so it is the thing that ends
+                // a job whose worker went away rather than drawing its spinner for ever.
+                await svc.imports.reap(tx, input.workspaceId).catch(() => 0);
+                const rows = await svc.imports.list(tx, input.workspaceId, context.principal, input.limit);
+                return rows.map((row) => {
+                    const { report, ...summary } = svc.imports.toImportJob(row);
+                    return summary;
+                });
+            })),
+        },
+        /**
+         * What somebody writes with.
+         *
+         * Two permissions and a rule for telling them apart: **using** a template is `quire.page.create`,
+         * because what it does is make a page; **changing** one is `quire.space.manage`, because it
+         * changes what everybody in the space is offered the next time they make one. That is exactly
+         * how `labels.*` above is split, and for the same reason.
+         *
+         * A template id carries no scope of its own, so every procedure here that takes one reads the
+         * row first and asks about the space it belongs to. A **workspace-wide** template
+         * (`space_id is null`) has no narrower scope than the workspace, and the workspace-level
+         * `requires()` is the whole answer for it — said out loud here rather than left as a space check
+         * that silently falls back to the space of whoever happened to ask.
+         */
+        templates: {
+            list: scoped.templates.list.use(requires('quire.space.view')).handler(({ input, context }) => run(context, input.workspaceId, async (tx) => {
+                /*
+                 * A space named is a space checked. Without one the question is "what is offered
+                 * everywhere", which the "New space" picker asks before there is a space to ask about —
+                 * and `requires()` is the only scope that exists for it.
+                 */
+                if (input.spaceId) {
+                    await svc.access.spaceRow(tx, input.workspaceId, input.spaceId);
+                    await svc.access.requireSpace(context.principal, 'quire.space.view', input.workspaceId, input.spaceId);
+                }
+                return svc.templates.list(tx, input.workspaceId, input.kind, input.spaceId, context.principal.locale);
+            })),
+            get: scoped.templates.get.use(requires('quire.space.view')).handler(({ input, context }) => run(context, input.workspaceId, async (tx) => {
+                const row = await svc.templates.row(tx, input.workspaceId, input.templateId);
+                if (row.spaceId) {
+                    await svc.access.spaceRow(tx, input.workspaceId, row.spaceId);
+                    await svc.access.requireSpace(context.principal, 'quire.space.view', input.workspaceId, row.spaceId);
+                }
+                return toTemplate(row);
+            })),
+            /**
+             * Two questions, not one, and the first is the one that protects anything.
+             *
+             * This copies a page's prose into something everybody who may create a page can then read, so
+             * **may you read what you are copying** is asked against the page's own ancestor chain — a
+             * contractor allowed one page of a handbook must not be able to lift a neighbouring page into
+             * a template and read it there. Only then is "may you configure where it is offered" asked.
+             */
+            createFromPage: scoped.templates.createFromPage
+                .use(requires('quire.space.manage'))
+                .handler(async ({ input, context }) => {
+                const template = await run(context, input.workspaceId, async (tx) => {
+                    if (input.kind === 'space') {
+                        await svc.access.spaceRow(tx, input.workspaceId, input.sourceId);
+                        await svc.access.requireSpace(context.principal, 'quire.space.manage', input.workspaceId, input.sourceId);
+                    }
+                    else {
+                        await requirePage(tx, context, input.workspaceId, input.sourceId, 'quire.page.view');
+                        if (input.spaceId)
+                            await svc.access.requireSpace(context.principal, 'quire.space.manage', input.workspaceId, input.spaceId);
+                    }
+                    return svc.templates.createFromPage(tx, context.principal, input.workspaceId, input);
+                });
+                await announce(input.workspaceId, 'template', template.id, 'created');
+                return template;
+            }),
+            update: scoped.templates.update
+                .use(requires('quire.space.manage'))
+                .handler(async ({ input, context }) => {
+                const { workspaceId, templateId, ...patch } = input;
+                const template = await run(context, workspaceId, async (tx) => {
+                    const existing = await svc.templates.row(tx, workspaceId, templateId);
+                    if (existing.spaceId)
+                        await svc.access.requireSpace(context.principal, 'quire.space.manage', workspaceId, existing.spaceId);
+                    // Moving it into a space needs the same permission on the space it is moving into, or
+                    // "offered everywhere" would be a way to put a template in a space you may not configure.
+                    if (patch.spaceId)
+                        await svc.access.requireSpace(context.principal, 'quire.space.manage', workspaceId, patch.spaceId);
+                    /*
+                     * Replacing the body re-reads a page or a space, so the read is checked again exactly as
+                     * it is in `createFromPage`. The same act needs the same permission whichever door it
+                     * comes in by, and this is the door that is easy to forget: `update` looks like a rename.
+                     */
+                    if (patch.sourceId !== undefined) {
+                        if (existing.kind === 'space') {
+                            await svc.access.spaceRow(tx, workspaceId, patch.sourceId);
+                            await svc.access.requireSpace(context.principal, 'quire.space.manage', workspaceId, patch.sourceId);
+                        }
+                        else {
+                            await requirePage(tx, context, workspaceId, patch.sourceId, 'quire.page.view');
+                        }
+                    }
+                    return svc.templates.update(tx, context.principal, workspaceId, templateId, patch);
+                });
+                await announce(workspaceId, 'template', template.id, 'updated');
+                return template;
+            }),
+            remove: scoped.templates.remove
+                .use(requires('quire.space.manage'))
+                .handler(async ({ input, context }) => {
+                await run(context, input.workspaceId, async (tx) => {
+                    const existing = await svc.templates.row(tx, input.workspaceId, input.templateId);
+                    if (existing.spaceId)
+                        await svc.access.requireSpace(context.principal, 'quire.space.manage', input.workspaceId, existing.spaceId);
+                    await svc.templates.remove(tx, input.workspaceId, input.templateId);
+                });
+                await announce(input.workspaceId, 'template', input.templateId, 'deleted');
+                return { ok: true };
+            }),
+            /**
+             * Make the thing.
+             *
+             * The kind decides which permission is asked, and the template decides the kind — so the
+             * template is resolved before anything is checked. A page template asks `quire.page.create` on
+             * the space it writes into; a space template *creates* a space, so it asks
+             * `quire.space.manage` at workspace scope, which is the same question `spaces.create` asks and
+             * the only scope that exists before a space does.
+             */
+            instantiate: scoped.templates.instantiate
+                .use(requires('quire.page.create'))
+                .handler(async ({ input, context }) => {
+                /*
+                 * Which branch ran, recorded rather than inferred from the answer.
+                 *
+                 * `TemplateResult` is one shape for both kinds on purpose, so nothing in it says "a space
+                 * was made" — and guessing from `pageCount` would be wrong for the two cases that matter:
+                 * a space template whose tree is one page, and one whose tree is empty.
+                 */
+                let madeSpace = false;
+                const result = await run(context, input.workspaceId, async (tx) => {
+                    const resolved = await svc.templates.resolve(tx, input.workspaceId, context.principal.locale, input.templateId, input.starterKey);
+                    if (resolved.kind === 'space') {
+                        madeSpace = true;
+                        if (!input.key || !input.name)
+                            throw KernError.badRequest('A space template needs a name and an address for the space');
+                        await kernel.authz.require(context.principal, 'quire.space.manage', {
+                            kind: 'workspace',
+                            id: input.workspaceId,
+                            workspaceId: input.workspaceId,
+                        });
+                        return svc.templates.instantiateSpace(tx, context.principal, input.workspaceId, resolved, {
+                            key: input.key,
+                            name: input.name,
+                            values: input.values,
+                        });
+                    }
+                    if (!input.spaceId)
+                        throw KernError.badRequest('A page template needs a space to be made in');
+                    await svc.access.spaceRow(tx, input.workspaceId, input.spaceId);
+                    await svc.access.requireSpace(context.principal, 'quire.page.create', input.workspaceId, input.spaceId);
+                    return svc.templates.instantiatePage(tx, context.principal, input.workspaceId, resolved, {
+                        spaceId: input.spaceId,
+                        parentId: input.parentId,
+                        afterId: input.afterId,
+                        title: input.title,
+                        values: input.values,
+                    });
+                });
+                /*
+                 * A space template makes a space *and* a tree, so both are announced — the space list and
+                 * one space's tree are different screens, and announcing only the pages would leave the
+                 * space list empty until somebody reloaded.
+                 */
+                if (madeSpace) {
+                    await announce(input.workspaceId, 'space', result.spaceId, 'created');
+                    await kernel.emit(quireEvents.spaceCreated, { spaceId: result.spaceId, workspaceId: input.workspaceId }, { workspaceId: input.workspaceId, actorId: context.principal.userId });
+                }
+                /*
+                 * One event, for the page somebody is about to be taken to.
+                 *
+                 * A space template that made eleven pages emits one `pageCreated` and not eleven: an event
+                 * is what something *reacts* to, and eleven notifications for one act is the shape that
+                 * teaches people to mute a feed. `pageCount` in the answer is how a screen says how many.
+                 * A tree with no pages emits nothing rather than an event carrying an empty page id.
+                 */
+                if (result.pageId) {
+                    await announce(input.workspaceId, 'page', result.pageId, 'created', {
+                        spaceId: result.spaceId,
+                    });
+                    await kernel.emit(quireEvents.pageCreated, { pageId: result.pageId, spaceId: result.spaceId, workspaceId: input.workspaceId }, { workspaceId: input.workspaceId, actorId: context.principal.userId });
+                }
+                return result;
+            }),
+        },
         publishing: {
             publish: scoped.publishing.publish
                 .use(requires('quire.page.publish'))