@kernhq/module-quire 0.12.0 → 0.13.1

package/dist/server/_impl.d.ts

@@ -4942,7 +4942,7 @@ export declare function implement_(kernel: Kernel): {
             headers: Record<string, string | string[] | undefined>;
             workspaceId?: string;
         }, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            workspaceId: import("zod").ZodString;
             slug: import("zod").ZodString;
             token: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
@@ -5014,7 +5014,7 @@ export declare function implement_(kernel: Kernel): {
             headers: Record<string, string | string[] | undefined>;
             workspaceId?: string;
         }, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            workspaceId: import("zod").ZodString;
             slug: import("zod").ZodString;
             path: import("zod").ZodDefault<import("zod").ZodString>;
             basePath: import("zod").ZodDefault<import("zod").ZodString>;
@@ -5079,7 +5079,7 @@ export declare function implement_(kernel: Kernel): {
             headers: Record<string, string | string[] | undefined>;
             workspaceId?: string;
         }, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            workspaceId: import("zod").ZodString;
             slug: import("zod").ZodString;
             q: import("zod").ZodString;
             limit: import("zod").ZodDefault<import("zod").ZodNumber>;
@@ -5138,7 +5138,7 @@ export declare function implement_(kernel: Kernel): {
             headers: Record<string, string | string[] | undefined>;
             workspaceId?: string;
         }, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            workspaceId: import("zod").ZodString;
             slug: import("zod").ZodString;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             entries: import("zod").ZodArray<import("zod").ZodObject<{
@@ -5193,7 +5193,7 @@ export declare function implement_(kernel: Kernel): {
             headers: Record<string, string | string[] | undefined>;
             workspaceId?: string;
         }, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            workspaceId: import("zod").ZodString;
             slug: import("zod").ZodString;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             indexable: import("zod").ZodBoolean;
@@ -5221,6 +5221,62 @@ export declare function implement_(kernel: Kernel): {
                 }, import("zod/v4/core").$strip>;
             };
         }>>, Record<never, never>>;
+        asset: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, Record<never, never>>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers"> & {
+            principal: {
+                kind: "service" | "user" | "api_key" | "anonymous";
+                userId: (string & import("zod").$brand<"UserId">) | null;
+                email: string | null;
+                name: string | null;
+                locale: "en" | "fa" | "ar" | "de";
+                instanceAdmin: boolean;
+                service: string | null;
+                memberships: {
+                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
+                    role: "owner" | "admin" | "member" | "guest";
+                    roleIds: string[];
+                    groupIds: string[];
+                    status: "active" | "invited" | "suspended";
+                }[];
+                permissionVersion: number;
+                apiKeyScope?: "read" | "read_write" | undefined;
+            };
+            kernel: Kernel;
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+            workspaceId?: string;
+        }, import("zod").ZodObject<{
+            workspaceId: import("zod").ZodString;
+            slug: import("zod").ZodString;
+            asset: import("zod").ZodString;
+            token: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            contentType: import("zod").ZodString;
+            bytes: import("zod").ZodString;
+            maxAge: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
         unlock: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, Record<never, never>>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers"> & {
             principal: {
                 kind: "service" | "user" | "api_key" | "anonymous";
@@ -5246,7 +5302,7 @@ export declare function implement_(kernel: Kernel): {
             headers: Record<string, string | string[] | undefined>;
             workspaceId?: string;
         }, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            workspaceId: import("zod").ZodString;
             slug: import("zod").ZodString;
             password: import("zod").ZodString;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{

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;AAwC3D,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAksCxC"}
+{"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"}

package/dist/server/_impl.js

@@ -3,7 +3,7 @@ import { defineModule, defineServerModule, KernError, o, packageVersion, require
 import { implement } from '@orpc/server';
 import { MODULE_ID, quireContract, quireEvents } from '../contract/index.js';
 import { toComment } from './services/comments.js';
-import { quireServices } from './services/index.js';
+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';
@@ -28,11 +28,41 @@ const os = implement(quireContract).$context();
  * a URL is owed "there is nothing here" and not "there is something here that this customer has
  * switched off". The one thing it must not do is `requireMember`.
  */
+const UUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 const publicSurface = o.middleware(async ({ context, next }, input) => {
     const { workspaceId } = input;
-    if (typeof workspaceId !== 'string' || workspaceId.length === 0)
+    /*
+     * A middleware runs *before* the contract validates its input, so this is the first and only
+     * thing that sees the workspace segment — and it used to hand whatever arrived to
+     * `kernel.isModuleEnabled`, whose own schema is `z.uuid()`. So `/api/quire/public/not-a-uuid/x`
+     * came back as a ZodError this module has no case for: **HTTP 500** on the one surface that
+     * promises everything unresolvable is a 404, and a stack trace written at error level for every
+     * such request, on an endpoint anyone on the internet can reach as fast as they like.
+     *
+     * The shape is checked here instead. Anything that is not a workspace id is the same "there is
+     * nothing here" as a workspace that has switched Quire off — which is the right answer, because a
+     * signed-out stranger is owed no more than that. `.catch` covers the rest for the same reason: a
+     * settings lookup that fails must not become a 500 either.
+     */
+    if (typeof workspaceId !== 'string')
+        throw new KernError('NOT_FOUND', 'There is no published site at this address');
+    /*
+     * A public URL names its workspace by **slug**, because the address the share dialog copies is
+     * meant to be sent to somebody — and a uuid in a link is a receipt, not an address. This
+     * middleware is the first thing that sees the segment, so it is also the first thing that used to
+     * refuse it: a `UUID.test` here answered 404 for the module's own published URLs while the same
+     * site served perfectly under its id. Resolving happens here so that `isModuleEnabled` below is
+     * asked about a workspace rather than about a slug, whose schema is `z.uuid()` and would 500.
+     *
+     * A slug that names no workspace, and a slug that names one with no such publication, both reach
+     * the same 404 as a workspace nobody has — so this resolves an address without answering "does
+     * this workspace exist" for anyone who asks.
+     */
+    const resolved = await resolveWorkspaceSegment(context.kernel, workspaceId).catch(() => null);
+    if (!resolved)
         throw new KernError('NOT_FOUND', 'There is no published site at this address');
-    if (!(await context.kernel.isModuleEnabled(workspaceId, MODULE_ID)))
+    const enabled = await context.kernel.isModuleEnabled(resolved, MODULE_ID).catch(() => false);
+    if (!enabled)
         throw new KernError('NOT_FOUND', 'There is no published site at this address');
     return next();
 });
@@ -50,11 +80,44 @@ const publicSurface = o.middleware(async ({ context, next }, input) => {
  * procedure must answer a denied administrator and an anonymous request identically.
  */
 const anonymousOnly = o.middleware(({ context, next }) => next({ context: { ...context, principal: ANONYMOUS } }));
+/**
+ * The one refusal every unservable publication shares, in one place so it cannot drift.
+ *
+ * It drifted. A publication whose root page had since been trashed was 404 from `site` and `page`,
+ * **200 with an empty body** from `search` and `sitemap`, and `indexable: true` from `robots` — so
+ * four procedures written to be indistinguishable from "no such slug" were, between them, an
+ * existence oracle for a fifth state nobody had enumerated. And `page` said "page" where the others
+ * said "site", which separated a locked publication from a missing one on the endpoint least able
+ * to afford it.
+ *
+ * The rule the wording now follows: **a refusal about the publication says "site", and a refusal
+ * about a path inside a servable one says "page".** A reader who mistypes a page of a real handbook
+ * is the only person who ever sees the second sentence.
+ */
+const noSite = () => new KernError('NOT_FOUND', 'There is no published site at this address');
 export function implement_(kernel) {
     const scoped = os.use(workspaceScoped(MODULE_ID));
     const open = os.use(publicSurface).use(anonymousOnly);
     const svc = quireServices(kernel);
     const notify = createNotify(kernel);
+    /**
+     * A publication that can actually be served, and its whole tree, or `noSite`.
+     *
+     * Every anonymous read but `site` and `robots` starts here, so the four ways of not being
+     * servable — no such slug, expired, still locked, nothing left under the root — are one answer
+     * written once rather than four handlers agreeing by hand. `site` needs its own shape because
+     * `locked` is a state it reports rather than refuses, and `robots` because it never refuses at
+     * all.
+     */
+    const servable = async (tx, workspaceId, slug, token) => {
+        const pub = await svc.publications.bySlug(tx, workspaceId, slug);
+        if (!(await svc.publications.unlocked(pub, token)))
+            throw noSite();
+        const nodes = await svc.publications.tree(tx, workspaceId, pub);
+        if (!nodes[0])
+            throw noSite();
+        return { pub, nodes };
+    };
     const run = (context, workspaceId, fn) => kernel.database.withWorkspace(workspaceId, fn, { userId: context.principal.userId });
     /**
      * "May you do this to *that* page", answered through the page's ancestor chain.
@@ -834,17 +897,17 @@ export function implement_(kernel) {
          * transaction, so a write that slipped in here fails in Postgres rather than in a review.
          */
         public: {
-            site: open.public.site.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx) => {
-                const pub = await svc.publications.bySlug(tx, input.workspaceId, input.slug);
+            site: open.public.site.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx, ws) => {
+                const pub = await svc.publications.bySlug(tx, ws, input.slug);
                 const theme = pub.theme;
                 if (!(await svc.publications.unlocked(pub, input.token)))
                     return { slug: pub.slug, theme, locked: true, site: null };
-                const nodes = await svc.publications.tree(tx, input.workspaceId, pub);
+                const nodes = await svc.publications.tree(tx, ws, pub);
                 // No root means the root page is archived, trashed, opted out, unpublished or not a page.
                 // The publication row survives that; the site does not.
                 const root = nodes[0];
                 if (!root)
-                    throw new KernError('NOT_FOUND', 'There is no published site at this address');
+                    throw noSite();
                 const newest = nodes.reduce((at, node) => Math.max(at, node.published_at.getTime()), root.published_at.getTime());
                 return {
                     slug: pub.slug,
@@ -865,18 +928,15 @@ export function implement_(kernel) {
                     },
                 };
             })),
-            page: open.public.page.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx) => {
-                const pub = await svc.publications.bySlug(tx, input.workspaceId, input.slug);
-                if (!(await svc.publications.unlocked(pub, input.token)))
-                    throw new KernError('NOT_FOUND', 'There is no published page at this address');
-                const nodes = await svc.publications.tree(tx, input.workspaceId, pub);
+            page: open.public.page.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx, ws) => {
+                const { nodes } = await servable(tx, ws, input.slug, input.token);
                 const node = svc.publications.find(nodes, input.path);
                 return {
                     path: node.path,
                     title: node.title || 'Untitled',
                     icon: node.icon,
                     coverUrl: node.cover_url,
-                    html: await svc.publications.html(tx, input.workspaceId, node, nodes, input.basePath),
+                    html: await svc.publications.html(tx, ws, node, nodes, input.basePath),
                     /*
                      * The version's timestamp, not the page's. `pages.updated_at` moves every time somebody
                      * types in the draft, so publishing it would tell the internet when an unpublished
@@ -887,12 +947,9 @@ export function implement_(kernel) {
                     breadcrumbs: trailTo(nodes, node),
                 };
             })),
-            search: open.public.search.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx) => {
-                const pub = await svc.publications.bySlug(tx, input.workspaceId, input.slug);
-                if (!(await svc.publications.unlocked(pub, input.token)))
-                    throw new KernError('NOT_FOUND', 'There is no published site at this address');
-                const nodes = await svc.publications.tree(tx, input.workspaceId, pub);
-                const hits = await svc.publications.search(tx, input.workspaceId, nodes, input.q, input.limit);
+            search: open.public.search.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx, ws) => {
+                const { nodes } = await servable(tx, ws, input.slug, input.token);
+                const hits = await svc.publications.search(tx, ws, nodes, input.q, input.limit);
                 return {
                     items: hits.map((hit) => ({
                         path: hit.node.path,
@@ -901,14 +958,19 @@ export function implement_(kernel) {
                     })),
                 };
             })),
-            sitemap: open.public.sitemap.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx) => {
-                const pub = await svc.publications.bySlug(tx, input.workspaceId, input.slug);
+            sitemap: open.public.sitemap.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx, ws) => {
+                const pub = await svc.publications.bySlug(tx, ws, input.slug);
                 // A sitemap exists for crawlers, so a site nobody is meant to crawl has an empty one
                 // rather than a private one. Answering with the tree here would put every path of a
                 // password-protected handbook in a file whose whole purpose is to be fetched by robots.
                 if (pub.passwordHash || !pub.indexable)
                     return { entries: [] };
-                const nodes = await svc.publications.tree(tx, input.workspaceId, pub);
+                const nodes = await svc.publications.tree(tx, ws, pub);
+                // A publication whose root has since been trashed serves nothing, so it is the same 404
+                // as a slug nobody took — an empty sitemap here would say "this address is a site" to a
+                // crawler that has just been told the opposite by every other procedure.
+                if (!nodes[0])
+                    throw noSite();
                 return {
                     entries: nodes.map((node) => ({
                         path: node.path,
@@ -916,19 +978,44 @@ export function implement_(kernel) {
                     })),
                 };
             })),
-            robots: open.public.robots.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx) => {
-                // The one place a missing publication is not an error: a crawler asking about a slug
-                // nobody has taken, one that has expired, and one behind a password have to get the same
-                // answer, or this becomes the oracle every other procedure refuses to be.
-                const pub = await svc.publications.bySlug(tx, input.workspaceId, input.slug).catch(() => null);
+            robots: open.public.robots.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx, ws) => {
+                /*
+                 * The one place a missing publication is not an error: a crawler asking about a slug
+                 * nobody has taken, one that has expired, and one behind a password have to get the same
+                 * answer, or this becomes the oracle every other procedure refuses to be.
+                 *
+                 * There is a **fourth** state and this comment used to list three. A publication whose
+                 * root page has since been trashed, archived, opted out or unpublished still has its row:
+                 * `site`, `page`, `search` and `sitemap` all answer 404 for it, and robots answered
+                 * `indexable: true` with a sitemap path — so the one procedure written to never
+                 * distinguish anything was the only one admitting that the slug existed. It is the walk
+                 * rather than the row that decides, which is why the tree is read here.
+                 */
+                const pub = await svc.publications.bySlug(tx, ws, input.slug).catch(() => null);
                 if (!pub || pub.passwordHash || !pub.indexable)
                     return { indexable: false, sitemapPath: null };
+                const nodes = await svc.publications.tree(tx, ws, pub);
+                if (!nodes[0])
+                    return { indexable: false, sitemapPath: null };
                 // Relative to whatever prefix the route layer serves this site under; the module has no
                 // way to know that, and guessing would put a wrong absolute URL in a robots file.
                 return { indexable: true, sitemapPath: 'sitemap.xml' };
             })),
-            unlock: open.public.unlock.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx) => {
-                const pub = await svc.publications.bySlug(tx, input.workspaceId, input.slug);
+            /**
+             * The bytes of one picture on a published page.
+             *
+             * It goes through `servable` like every other read, so a picture is behind the same door, the
+             * same expiry and the same walk as the prose it sits in — and `svc.publications.asset` then
+             * insists the file is referenced by a version *in this tree* before it fetches anything. That
+             * second check is what stops a reference lifted out of one published site from resolving
+             * against another in the same workspace.
+             */
+            asset: open.public.asset.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx, ws) => {
+                const { nodes } = await servable(tx, ws, input.slug, input.token);
+                return svc.publications.asset(tx, ws, nodes, input.asset);
+            })),
+            unlock: open.public.unlock.handler(({ input }) => svc.publications.read(input.workspaceId, async (tx, ws) => {
+                const pub = await svc.publications.bySlug(tx, ws, input.slug);
                 // A site with no password has no door to open, and saying so would confirm the slug
                 // exists to somebody who has not been told anything else about it.
                 if (!pub.passwordHash)