smoodly 0.0.52 → 0.0.53

package/dist/admin/handler.d.ts

@@ -3,7 +3,7 @@ import type { PresenceConfig } from "../env.ts";
 import { type KeySet } from "../signed-message.ts";
 import { type AdminFiles } from "./files.ts";
 import type { AdminEffects } from "./ops.ts";
-import type { SignInConfig } from "./auth-config.ts";
+import type { SignInConfig } from "./session-flow.ts";
 export type AdminHandlerDeps = {
     config: ResolvedConfig;
     /** Where the browser sends a person to sign in, and the dashboard it links to: public values only. Absent, the page

package/dist/admin/index.d.ts

@@ -1,10 +1,10 @@
 export type { AdminEffects, AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError, PageCreateInput, PageGetResult, GlobalListItem, GlobalGetResult, AssetUsageItem, MembersListResult } from "./ops.ts";
-export type { InviteInput, InviteResult, MemberRecord } from "../member-store.ts";
+export type { MemberRecord } from "../member-store.ts";
 export type { MemberRole } from "../permissions.ts";
 export { fixedNodeSpecs, fixedNodeOf, type FixedNode } from "./fixed-nodes.ts";
 export { initialGlobalFields } from "./global-items.ts";
 export { makeClientOps } from "./client-ops.ts";
-export type { SignInConfig } from "./auth-config.ts";
+export type { SignInConfig } from "./session-flow.ts";
 export { serializeAdminConfig } from "./serialize.ts";
 export type { AdminRegistry, AdminSection, AdminCollection, AdminPageTemplate, AdminGlobal, AdminField } from "./serialize.ts";
 export * from "./tree-ops.ts";

package/dist/admin/ops.d.ts

@@ -3,7 +3,7 @@ import type { PageTree } from "../page-context.ts";
 import type { EntryRecord, EntryUsage } from "../entry-store.ts";
 import type { AssetRecord, AssetMeta } from "../media.ts";
 import type { AssetPage, AssetQuery } from "../asset-store.ts";
-import type { InviteInput, InviteResult, MemberRecord } from "../member-store.ts";
+import type { MemberRecord } from "../member-store.ts";
 import type { MemberRole } from "../permissions.ts";
 import type { FieldError } from "./validate.ts";
 import type { DeployState } from "../deploy-state.ts";
@@ -126,10 +126,9 @@ export type AssetUsageItem = {
     title: string;
     href: string | null;
 };
-/** The Members page's read (spec 2026-09-25 §4): the rows and, when the control plane manages them, where. */
+/** The Members page's read (spec 2026-09-25 §4): the rows; the dashboard manages them. */
 export type MembersListResult = {
     members: MemberRecord[];
-    consoleUrl: string | null;
 };
 /** `database` null = no smoodly_meta table (older than v1). Behind blocks the shell; ahead is silent (spec 2026-09-26 §5). */
 /** The Deploy tile's state (spec 2026-10-09 static mode §6); `hook` false = SMOODLY_DEPLOY_HOOK is unset, Deploy disabled. */
@@ -254,18 +253,13 @@ export type AdminOps = {
         usage(id: string): Promise<OpResult<AssetUsageItem[]>>;
     };
     members: {
-        /** The space's members; admins only. `consoleUrl` set means smoodly.io manages them and every write below is blocked. */
+        /** The space's members, a read-only list; admins only. Invites, roles and removals are the dashboard's
+         *  (spec 2026-10-16 sign-in and the dashboard §6). */
         list(): Promise<OpResult<MembersListResult>>;
         /** The caller's role; every member. The shell hides Settings from editors with it. */
         me(): Promise<OpResult<{
             role: MemberRole;
         }>>;
-        /** Admins only, self-host only: invites (or adds an existing account), refuses a duplicate row (spec 2026-09-25 members management §3). */
-        invite(input: InviteInput): Promise<OpResult<InviteResult>>;
-        /** Admins only, self-host only; never your own row, never the last admin. */
-        setRole(userId: string, role: MemberRole): Promise<OpResult<MemberRecord>>;
-        /** Admins only, self-host only; the same two guards. The Auth account stays. */
-        remove(userId: string): Promise<OpResult<null>>;
     };
     /** Redirects by hand (spec 2026-09-26 redirects §5): open to every member, as renaming is; nothing here expires a cache. */
     redirects: {

package/dist/admin/page-data.d.ts

@@ -1,6 +1,6 @@
 import type { PresenceConfig } from "../env.ts";
 import type { AdminRegistry } from "./serialize.ts";
-import type { SignInConfig } from "./auth-config.ts";
+import type { SignInConfig } from "./session-flow.ts";
 export type AdminPageData = {
     registry: AdminRegistry;
     /** Where the browser sends a person to sign in and the dashboard it links to: public values only. */

package/dist/admin/session-flow.d.ts

@@ -1,5 +1,11 @@
 import type { MemberRole } from "../permissions.ts";
-import type { SignInConfig } from "./auth-config.ts";
+/** Where the admin sends a person to sign in, and the dashboard its account menu and Members page link to (spec
+ *  2026-10-16 sign-in and the dashboard §1, §6): `GET /v1/auth` answers it from the Worker's env; the handler and the
+ *  page data carry it. Public values only. */
+export type SignInConfig = {
+    signInUrl: string;
+    consoleUrl: string;
+};
 export declare const STORAGE_KEY: (space: string) => string;
 /** The PKCE verifier, in this tab's `sessionStorage` only: the code is good for the browser tab that asked for it. */
 export declare const VERIFIER_KEY = "smoodly-verifier";
@@ -26,10 +32,26 @@ export declare function readSession(local: Storage, space: string): StoredSessio
 export declare function signInAddress(config: SignInConfig, space: string, returnUrl: string, stores: Pick<SessionStores, "tab">): Promise<string>;
 /** The one-time code the sign-in page put in the fragment, or null. */
 export declare function codeFrom(hash: string): string | null;
-/** The code and this tab's verifier for a session, stored; or why not. The verifier is spent either way. */
+/** What the admin shows when the service cannot be reached at sign-in: a refusal with a way back, never a blank screen. */
+export declare const UNREACHABLE = "smoodly: couldn't reach Smoodly to sign you in \u2014 check the connection and sign in again.";
+/** The code and this tab's verifier for a session, stored; or why not. The verifier is spent either way. A service
+ *  that cannot be reached is a refusal too (UNREACHABLE), so the shell shows it rather than waiting forever. */
 export declare function exchange(api: string, space: string, code: string, stores: SessionStores, doFetch?: typeof fetch): Promise<StoredSession | {
     refused: string;
 }>;
+/** The load-time step with no code in the fragment: the stored session adopted as it is while its pass has more than
+ *  RENEW_BEFORE_MS left, else renewed; a renewal the service refuses sends the person to sign in; one that cannot reach
+ *  the service keeps a pass that is still valid (the next timer tries again) and refuses with UNREACHABLE only once the
+ *  pass has expired. No stored session: sign in. */
+export declare function resume(api: string, space: string, stores: Pick<SessionStores, "local">, now: number, doFetch?: typeof fetch, lock?: TabLock): Promise<{
+    kind: "adopt";
+    session: StoredSession;
+} | {
+    kind: "sign_in";
+} | {
+    kind: "refused";
+    message: string;
+}>;
 /** Runs `fn` while holding a lock no other tab of this origin holds (Web Locks); with no Web Locks (an insecure
  *  context), at once. */
 export type TabLock = <T>(name: string, fn: () => Promise<T>) => Promise<T>;

package/dist/admin/session-flow.js

@@ -38,18 +38,45 @@ async function post(doFetch, url, body) {
     const json = (await res.json().catch(() => null));
     return { status: res.status, data: json?.ok ? json.data : null, message: typeof json?.message === "string" ? json.message : null };
 }
-/** The code and this tab's verifier for a session, stored; or why not. The verifier is spent either way. */
+/** What the admin shows when the service cannot be reached at sign-in: a refusal with a way back, never a blank screen. */
+export const UNREACHABLE = "smoodly: couldn't reach Smoodly to sign you in — check the connection and sign in again.";
+/** The code and this tab's verifier for a session, stored; or why not. The verifier is spent either way. A service
+ *  that cannot be reached is a refusal too (UNREACHABLE), so the shell shows it rather than waiting forever. */
 export async function exchange(api, space, code, stores, doFetch = fetch) {
     const verifier = stores.tab.getItem(VERIFIER_KEY);
     stores.tab.removeItem(VERIFIER_KEY);
     if (!verifier)
         return { refused: "smoodly: this sign-in was started in another tab or has already been used — sign in again." };
-    const answer = await post(doFetch, sessionUrl(api, space, "session"), { code, verifier });
+    let answer;
+    try {
+        answer = await post(doFetch, sessionUrl(api, space, "session"), { code, verifier });
+    }
+    catch {
+        return { refused: UNREACHABLE };
+    }
     if (answer.status !== 200 || !isSession(answer.data))
         return { refused: answer.message ?? `smoodly: the sign-in was refused (${answer.status}).` };
     writeSession(stores.local, space, answer.data);
     return answer.data;
 }
+/** The load-time step with no code in the fragment: the stored session adopted as it is while its pass has more than
+ *  RENEW_BEFORE_MS left, else renewed; a renewal the service refuses sends the person to sign in; one that cannot reach
+ *  the service keeps a pass that is still valid (the next timer tries again) and refuses with UNREACHABLE only once the
+ *  pass has expired. No stored session: sign in. */
+export async function resume(api, space, stores, now, doFetch = fetch, lock = tabLock) {
+    const stored = readSession(stores.local, space);
+    if (!stored)
+        return { kind: "sign_in" };
+    if (stored.expiresAt - now > RENEW_BEFORE_MS)
+        return { kind: "adopt", session: stored };
+    try {
+        const renewed = await renew(api, space, stores, stored.refresh, doFetch, lock);
+        return renewed ? { kind: "adopt", session: renewed } : { kind: "sign_in" };
+    }
+    catch {
+        return stored.expiresAt > now ? { kind: "adopt", session: stored } : { kind: "refused", message: UNREACHABLE };
+    }
+}
 const tabLock = (name, fn) => {
     const locks = globalThis.navigator?.locks;
     return locks ? locks.request(name, fn) : fn();

package/dist/admin/shell/AdminApp.d.ts

@@ -1,6 +1,6 @@
 import type { AdminOpAction } from "../ops.ts";
 import type { AdminRegistry } from "../serialize.ts";
-import type { SignInConfig } from "../auth-config.ts";
+import type { SignInConfig } from "../session-flow.ts";
 import type { PresenceConfig } from "../../env.ts";
 export declare function AdminApp({ registry, op, signIn, api, presenceConfig }: {
     registry: AdminRegistry;

package/dist/admin/shell/IconRail.js

@@ -1,10 +1,11 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // packages/smoodly/src/admin/shell/IconRail.tsx
-// The admin's primary navigation: the design system's 72px IconRail
-// (design_handoff_smoodly_cms/components/navigation/IconRail), which
-// replaced the 200px SideNav so the visual editor gets the width. Ported
-// markup-for-markup; the handoff's click handlers are the shell's router.
+// The admin's primary navigation: the design handoff's 72px IconRail (the
+// cool-blue look's components/navigation/IconRail, in the tree until 2026-10-19;
+// the shipped tokens are design_handoff_smoodly_neutral/), which replaced the
+// 200px SideNav so the visual editor gets the width. Ported markup-for-markup;
+// the handoff's click handlers are the shell's router.
 //
 // Items are registry-derived, never separately configured: Pages, then
 // Collections — one rail item whose flyout lists every collection — then

package/dist/admin/shell/presence.d.ts

@@ -15,7 +15,7 @@ export type PresenceState = {
     status: PresenceStatus;
     others: PresenceEntry[];
 };
-/** The channel presence uses: once a Realtime channel's slice, now the service's socket (presence-socket.ts). */
+/** The channel presence uses: the service's socket (presence-socket.ts). */
 export type PresenceChannel = {
     subscribe(onStatus: (status: string) => void): void;
     /** The session renewed (its new pass): reconnect with a fresh ticket. The space's object admits a live session of a

package/dist/admin/shell/session.d.ts

@@ -1,5 +1,4 @@
-import type { SignInConfig } from "../auth-config.ts";
-import { type StoredSession } from "../session-flow.ts";
+import { type SignInConfig, type StoredSession } from "../session-flow.ts";
 export type SessionUser = StoredSession["user"];
 export type SessionState = {
     status: "loading";

package/dist/admin/shell/session.js

@@ -7,7 +7,7 @@
 // straight back in while their smoodly.io session lives. Another tab's renewal or sign out is adopted from the
 // `storage` event. The pure steps are admin/session-flow.ts.
 import { useCallback, useEffect, useRef, useState } from "react";
-import { codeFrom, endSession, exchange, readSession, renew, RENEW_BEFORE_MS, signInAddress, STORAGE_KEY } from "../session-flow.js";
+import { codeFrom, endSession, exchange, readSession, renew, RENEW_BEFORE_MS, resume, signInAddress, STORAGE_KEY } from "../session-flow.js";
 /** A renewal's timer fires up to this much later, so two tabs rarely post the same refresh at once. */
 const JITTER_MS = 30000;
 export function useSpaceSession({ apiUrl, spaceId, signIn }) {
@@ -69,16 +69,17 @@ export function useSpaceSession({ apiUrl, spaceId, signIn }) {
                     adopt(got);
                 return;
             }
-            const stored = readSession(window.localStorage, spaceId);
-            if (!stored) {
-                await signInAgain();
+            // The stored session, as it is or renewed; a service that cannot be reached keeps a still-valid pass and
+            // refuses, with a way back, only once it has expired (session-flow.ts resume).
+            const step = await resume(apiUrl, spaceId, stores(), Date.now());
+            if (!live)
                 return;
-            }
-            held.current = stored;
-            if (stored.expiresAt - Date.now() > RENEW_BEFORE_MS)
-                adopt(stored);
+            if (step.kind === "adopt")
+                adopt(step.session);
+            else if (step.kind === "refused")
+                setState({ status: "signed_out", reason: "refused", message: step.message });
             else
-                await renewNow();
+                await signInAgain();
         })();
         const onStorage = (e) => {
             if (e.key !== STORAGE_KEY(spaceId))

package/dist/admin/ui/primitives.js

@@ -1,7 +1,8 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // The design system's primitives, ported 1:1 from the handoff's
-// components/ set (design_handoff_smoodly_cms). Structure and dynamic
+// components/ set (the cool-blue look, in the tree until 2026-10-19; the shipped
+// tokens are design_handoff_smoodly_neutral/). Structure and dynamic
 // values live here; every static rule, and all hover/focus state, lives in
 // theme.tsx's stylesheet.
 import { Fragment, useEffect, useRef } from "react";

package/dist/api-client.js

@@ -65,7 +65,7 @@ export function createSmoodlyApi(options) {
             return (await call("/target-paths", { kind: target.kind, id: target.id })).data;
         },
         async load(target, locale, path, o) {
-            const draft = !!o?.draft || o?.version !== undefined;
+            const draft = !!o?.draft || !!o?.version;
             const r = await call("/load", { kind: target.kind, id: target.id, locale, path, draft: o?.draft ? "1" : undefined, version: o?.version });
             return withTags(r.data, r.tags, draft);
         },

package/dist/assemble.js

@@ -49,7 +49,7 @@ export function checkEntryQuery(schema, collection, o) {
         if (OBJECT_FIELD_TYPES.has(schema.fields[key].type ?? "")) {
             throw new Error(`smoodly: getEntries("${collection}"): "${key}" holds an object — filter on a scalar field instead.`);
         }
-        // Any-of reads the text form of the whole field (PostgREST's `->>`), which for
+        // Any-of reads the text form of the whole field (an array as its JSON text), which for
         // an array is its JSON — `["a"]` never matches "a" — so refuse rather than match nothing.
         if (Array.isArray(o.where[key]) && ARRAY_FIELD_TYPES.has(schema.fields[key].type ?? "")) {
             throw new Error(`smoodly: getEntries("${collection}"): "${key}" is array-valued — any-of is for scalar fields; pass one value to match entries containing it.`);

package/dist/astro/cache.d.ts

@@ -17,7 +17,7 @@ export type Settled = {
     draft: boolean;
     /** The request is under the preview address, cookie or not. */
     preview: boolean;
-    /** The shell rendered a page read from the database and gave it a lifetime. */
+    /** The shell rendered a page read from the service and gave it a lifetime. */
     cacheable: boolean;
     /** When the request began, in milliseconds. */
     started: number;

package/dist/astro/index.js

@@ -79,11 +79,16 @@ export default function smoodly(options = {}) {
     let staticMedia = new Map();
     /** astro.config's `i18n`, which the build holds the config's `routing` against. */
     let i18n;
-    /** The project's API client at build, from its config file (the one `options.config` names) and the env the setup hook loaded. */
-    const buildApi = async () => {
-        const loaded = options.config ? await loadConfigFile(join(root, options.config), root) : await loadConfig(root);
+    /** The project's config at build, from its config file (the one `options.config` names), loaded once and shared by
+     *  every hook; and its API client, from the env the setup hook loaded, made once. Two steps, since the routing
+     *  check wants the config before any env is needed. */
+    let builtConfig = null;
+    const buildConfig = () => (builtConfig ?? (builtConfig = options.config ? loadConfigFile(join(root, options.config), root) : loadConfig(root)));
+    let builtApi = null;
+    const buildApi = () => (builtApi ?? (builtApi = (async () => {
+        const loaded = await buildConfig();
         return { loaded, api: createSmoodlyApi({ ...apiEnv(process.env), config: loaded }) };
-    };
+    })()));
     /** A build read that fails names the service's address and stops the build before any page renders (a static build
      *  with the Worker down would otherwise fail page by page). */
     const fromApi = async (read) => {
@@ -115,7 +120,7 @@ export default function smoodly(options = {}) {
                     injectRoute(route);
                 addMiddleware({ entrypoint: here(`./middleware${ext}`), order: "pre" });
                 if (output === "server" && !config.cache?.provider) {
-                    logger.warn("smoodly: no cache provider in astro.config — every page renders from the database. Add `cache: { provider: memoryCache() }` (from \"astro/config\").");
+                    logger.warn("smoodly: no cache provider in astro.config — every page renders from the service. Add `cache: { provider: memoryCache() }` (from \"astro/config\").");
                 }
                 // astro.config is evaluated before Astro loads .env, so `site: process.env.SITE_URL` there sees only the
                 // shell's value; the env files were read above, and SITE_URL from them sets `site` here. A value
@@ -149,7 +154,7 @@ export default function smoodly(options = {}) {
             // The schema push (spec 2026-10-16 the control plane §4) comes first, in either output: the space then holds the
             // registry this build renders with. A failed push never fails the build; the site runs against the schema the space has.
             "astro:build:start": async ({ logger }) => {
-                const loaded = options.config ? await loadConfigFile(join(root, options.config), root) : await loadConfig(root);
+                const loaded = await buildConfig();
                 // The runtime's startup check, at build in either output: a deploy that builds must not refuse every request.
                 astroRouting(i18n, loaded.locales, loaded.routing);
                 try {

package/dist/astro/runtime.d.ts

@@ -19,7 +19,7 @@ export type { PageHead } from "./head.ts";
 export type { ViewFiles } from "./views-check.ts";
 import { type Shell, type SmoodlyLocals } from "./shell.ts";
 /** The shell's decision with the project's bound site: what routes/page.astro calls, with `Astro.cache`.
- *  A page read from the database gets its lifetime here, before its view renders. The first call compares
+ *  A page read from the service gets its lifetime here, before its view renders. The first call compares
  *  the project's view files to the registry and names every disagreement once. */
 export declare function shell(pathname: string, search: string, state: SmoodlyLocals, views: ViewFiles, cache?: unknown): Promise<Shell>;
 /** getStaticPaths for the static page shell (spec 2026-10-09 static mode §3): every published address of the bound site. */

package/dist/astro/runtime.js

@@ -25,7 +25,7 @@ import { missingViews } from "./views-check.js";
 import { resolveShell } from "./shell.js";
 let viewsChecked = false;
 /** The shell's decision with the project's bound site: what routes/page.astro calls, with `Astro.cache`.
- *  A page read from the database gets its lifetime here, before its view renders. The first call compares
+ *  A page read from the service gets its lifetime here, before its view renders. The first call compares
  *  the project's view files to the registry and names every disagreement once. */
 export async function shell(pathname, search, state, views, cache) {
     if (!viewsChecked) {

package/dist/astro/shell.d.ts

@@ -14,7 +14,7 @@ export type SmoodlyLocals = {
     editor: boolean;
     /** History's stored version, inside a preview only. */
     version?: string;
-    /** Set by the shell when it rendered a page read from the database: the response may be cached under its tags. */
+    /** Set by the shell when it rendered a page read from the service: the response may be cached under its tags. */
     cacheable: boolean;
     /** Set by the shell when it rendered a page at all: in a preview, only that response is a canvas. */
     shell: boolean;

package/dist/astro/shell.js

@@ -52,7 +52,7 @@ export async function resolveShell(deps, pathname, search, state, views) {
         console.warn(`smoodly: no src/page-types/${hit.template}.astro — the record at ${hit.path} is a 404.`);
         return NOT_FOUND;
     }
-    // Only a page read from the database has a tag to expire it by.
+    // Only a page read from the service has a tag to expire it by.
     state.cacheable = !hit.record.id.startsWith("code:") && !state.draft;
     state.shell = true;
     const zoneNames = Object.keys(schema.zones ?? {});

package/dist/content/content-api.d.ts

@@ -22,6 +22,7 @@ export declare class SmoodlyContentError extends Error {
 /** What content() writes through: the operations, the paths index's lookup, an upload. */
 export type ContentTransport = {
     op(call: AdminOpCall): Promise<OpResult<unknown>>;
+    /** The target at an address, as a draft read: what the script is writing, never an edge copy. */
     locate(locale: string, path: string): Promise<PathHit | null>;
     upload(bytes: Uint8Array, filename: string, mime: string | undefined, meta: UploadMeta): Promise<ImageValue>;
 };

package/dist/content/content-api.js

@@ -45,7 +45,9 @@ export function apiTransport(options) {
     const json = (body) => ({ method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
     return {
         op: (call) => send("/op", json({ path: call.path, args: call.args })),
-        locate: (locale, path) => must(send(`/locate?${new URLSearchParams({ locale, path })}`)),
+        // A draft read (DESIGN §1 Content API › Writes): the caller holds the secret key and asks about what it is writing,
+        // and a draft read is never stored at the edge, so a script sees its own create at once.
+        locate: (locale, path) => must(send(`/locate?${new URLSearchParams({ locale, path, draft: "1" })}`)),
         // The bytes as the body with their length, the rest in the query (spec 2026-10-18 media on R2 and Images §4).
         async upload(bytes, filename, mime, meta) {
             const type = mime ?? mimeOf(filename);

package/dist/css.js

@@ -1,7 +1,7 @@
 // The custom-CSS box (spec 2026-09-14 §4): a per-section snippet the
 // wrapper nests under the section's own [data-smd-node] selector. CSS
 // can do two things beyond styling — pull a remote stylesheet and beacon
-// to a host — so those, the two legacy code hooks and the tag-closing
+// to a host — so those, the two old code hooks (`expression()`, `behavior:`) and the tag-closing
 // sequence are refused at save and stripped at render, in that order.
 // The checks run on the snippet with its CSS escapes decoded, so
 // `\75 rl(` cannot spell `url(` past them; and the braces must balance,

package/dist/entry-store.d.ts

@@ -58,8 +58,8 @@ export type Where = Record<string, WhereValue | WhereValue[]>;
  *  adapters read the text form of the whole array, never its elements). */
 export declare const ARRAY_FIELD_TYPES: ReadonlySet<string>;
 /** The memory adapter's and the tests' reading of `where`: a scalar matches an
- *  equal value or an array holding it (JSONB containment); an array is any-of,
- *  compared as text like PostgREST's `->>`. */
+ *  equal value or an array holding it (containment); an array is any-of,
+ *  compared as text (textForm). */
 export declare function matchesWhere(fields: Record<string, unknown>, where: Where): boolean;
 export type ListOptions = {
     /** Equality / any-of on shared fields, executed by the store (spec 2026-09-11 §3). */
@@ -256,8 +256,8 @@ export declare function entryTitleIn(record: EntryRecord, locale: string, schema
  * directions (the SQLite list compiler sorts nulls last to match);
  * the creation tiebreak follows `direction` for non-manual orders.
  * Declared fields compare numerically when both values are numbers,
- * otherwise as strings via `localeCompare` — the same order Postgres
- * gives the jsonb VALUE (`fields->x`) for one type; see MAINTAINERS.md's
- * follow-ups for the mixed-type and JSON-null edges.
+ * otherwise as strings via `localeCompare` — the order the SQLite store's
+ * `COLLATE NOCASE` gives for one type (ASCII only; see MAINTAINERS.md's
+ * follow-ups for the mixed-type, JSON-null and non-ASCII edges).
  */
 export declare function compareEntries(order: EntryOrder, seq: (e: EntryRecord) => number): (a: EntryRecord, b: EntryRecord) => number;

package/dist/entry-store.js

@@ -15,12 +15,12 @@ import { slugOf, unsupportedLocale } from "./paths.js";
  *  containment, and any-of on one is refused by the site layer (both
  *  adapters read the text form of the whole array, never its elements). */
 export const ARRAY_FIELD_TYPES = new Set(["checkboxes", "refList", "list", "tags"]);
-/** PostgREST's `->>`: a scalar's text, an array's or object's JSON text (Postgres
- *  spaces an object's text differently, but no scalar equals either form). */
+/** A field's text form: a scalar's text, an array's or object's JSON text (no scalar
+ *  equals either form), the same in every store. */
 const textForm = (value) => (value !== null && typeof value === "object" ? JSON.stringify(value) : String(value));
 /** The memory adapter's and the tests' reading of `where`: a scalar matches an
- *  equal value or an array holding it (JSONB containment); an array is any-of,
- *  compared as text like PostgREST's `->>`. */
+ *  equal value or an array holding it (containment); an array is any-of,
+ *  compared as text (textForm). */
 export function matchesWhere(fields, where) {
     return Object.entries(where).every(([key, want]) => {
         const have = fields[key];
@@ -134,9 +134,9 @@ export function entryTitleIn(record, locale, schema) {
  * directions (the SQLite list compiler sorts nulls last to match);
  * the creation tiebreak follows `direction` for non-manual orders.
  * Declared fields compare numerically when both values are numbers,
- * otherwise as strings via `localeCompare` — the same order Postgres
- * gives the jsonb VALUE (`fields->x`) for one type; see MAINTAINERS.md's
- * follow-ups for the mixed-type and JSON-null edges.
+ * otherwise as strings via `localeCompare` — the order the SQLite store's
+ * `COLLATE NOCASE` gives for one type (ASCII only; see MAINTAINERS.md's
+ * follow-ups for the mixed-type, JSON-null and non-ASCII edges).
  */
 export function compareEntries(order, seq) {
     return (a, b) => {

package/dist/image/markup.js

@@ -1,4 +1,4 @@
-// One image markup for both frameworks (spec 2026-10-18 media on R2 and Images §7; plan (c) decision 5): what
+// One image markup for both frameworks (spec 2026-10-18 media on R2 and Images §7): what
 // <SmoodlyImage> (React) and <Image> (Astro) render, decided here so both are only markup and a test holds them equal.
 // Plain HTML, no optimizer and no Smoodly JavaScript: a box, an <img> whose srcset lists the cut's widths, or a
 // <picture> with one <source> per crop the view places. Without a cut (locally, an SVG) the original is framed in CSS

package/dist/index.d.ts

@@ -30,8 +30,8 @@ export { assetErrors, kindOf, extensionFor, objectPath, PAGE_SIZE as ASSET_PAGE_
 export type { AssetStore, UploadTicket, FinishInput, AssetQuery, AssetPage, BeginUploadInput, CreateAssetInput } from "./asset-store.ts";
 export { imageDimensions } from "./image-dimensions.ts";
 export type { ImageQuality } from "./media-cut.ts";
-export { sortMembers, memberErrors } from "./member-store.ts";
-export type { MemberStore, MemberRecord, InviteInput, InviteResult } from "./member-store.ts";
+export { sortMembers } from "./member-store.ts";
+export type { MemberStore, MemberRecord } from "./member-store.ts";
 export { MEMBER_ROLES, can, normalizeRole, isMemberRole } from "./permissions.ts";
 export type { MemberRole, Capability } from "./permissions.ts";
 export { collectEntryRefs, collectTreeRefs } from "./refs.ts";

package/dist/index.js

@@ -21,7 +21,7 @@ export { defineConfig } from "./config.js";
 export { draftToken, sameToken, isDraftToken, assertFresh, StaleDraftError } from "./draft-token.js";
 export { assetErrors, kindOf, extensionFor, objectPath, PAGE_SIZE as ASSET_PAGE_SIZE } from "./asset-store.js";
 export { imageDimensions } from "./image-dimensions.js";
-export { sortMembers, memberErrors } from "./member-store.js";
+export { sortMembers } from "./member-store.js";
 export { MEMBER_ROLES, can, normalizeRole, isMemberRole } from "./permissions.js";
 export { collectEntryRefs, collectTreeRefs } from "./refs.js";
 export { richtextBlocks, elementSchemas, IMAGE_NODE, ELEMENT_NODE } from "./richtext-walk.js";

package/dist/media-cut.d.ts

@@ -6,7 +6,7 @@ export type PixelRect = {
     height: number;
 };
 /** The qualities a cut is made at: unsigned in the address like the width, so a list bounds what Images is asked to
- *  make (spec 2026-10-18 image quality and max width §2). 75 matched Vercel's optimizer in step 6's speed round. */
+ *  make (spec 2026-10-18 image quality and max width §2). 75 matched Vercel's optimizer in the 2026-10-18 speed round. */
 export declare const IMAGE_QUALITIES: readonly [50, 60, 75, 85, 95, 100];
 export type ImageQuality = (typeof IMAGE_QUALITIES)[number];
 export declare const DEFAULT_QUALITY: ImageQuality;

package/dist/media-cut.js

@@ -1,10 +1,10 @@
 /** The widths a cut is served at, plus the cut's own width; a wider one is never served (upscaling sells nothing).
  *  From 640 to 1080 they are Next's device sizes, so a phone gets what `next/image` gave it (a 412-pixel screen at 1.75
- *  finds 750, not 960; step 6 plan (d)'s speed round); 1536 spares a 1366- or 1440-wide laptop the 1920 (spec 2026-10-18
+ *  finds 750, not 960; the 2026-10-18 speed round); 1536 spares a 1366- or 1440-wide laptop the 1920 (spec 2026-10-18
  *  image quality and max width §5). */
 const CUT_WIDTHS = [320, 640, 750, 828, 1080, 1280, 1536, 1920, 2560];
 /** The qualities a cut is made at: unsigned in the address like the width, so a list bounds what Images is asked to
- *  make (spec 2026-10-18 image quality and max width §2). 75 matched Vercel's optimizer in step 6's speed round. */
+ *  make (spec 2026-10-18 image quality and max width §2). 75 matched Vercel's optimizer in the 2026-10-18 speed round. */
 export const IMAGE_QUALITIES = [50, 60, 75, 85, 95, 100];
 export const DEFAULT_QUALITY = 75;
 export const isImageQuality = (n) => IMAGE_QUALITIES.includes(n);

package/dist/media.d.ts

@@ -115,7 +115,7 @@ export declare const ASSET_COLLECTION = "asset";
 export declare const MEDIA_TYPES: ReadonlySet<string>;
 /** Cache lifetime of a media object, in seconds — a year. Objects are
  *  immutable (no upsert; Replace picks a new id), so the CDN, the browser
- *  and next/image may keep one for as long as they like. */
+ *  may keep one for as long as they like. */
 export declare const MEDIA_CACHE_SECONDS = 31536000;
 /** The largest file a space may accept (spec 2026-10-18 media on R2 and Images §4): Cloudflare's request body limit on
  *  Free and Pro, since every upload streams through the Worker; a pushed `media.maxSize` over it is refused. */

package/dist/media.js

@@ -5,7 +5,7 @@ export const ASSET_COLLECTION = "asset";
 export const MEDIA_TYPES = new Set(["image", "video", "file"]);
 /** Cache lifetime of a media object, in seconds — a year. Objects are
  *  immutable (no upsert; Replace picks a new id), so the CDN, the browser
- *  and next/image may keep one for as long as they like. */
+ *  may keep one for as long as they like. */
 export const MEDIA_CACHE_SECONDS = 31536000;
 /** The largest file a space may accept (spec 2026-10-18 media on R2 and Images §4): Cloudflare's request body limit on
  *  Free and Pro, since every upload streams through the Worker; a pushed `media.maxSize` over it is refused. */
@@ -113,7 +113,7 @@ const namedCropsOf = (d) => d.crops && typeof d.crops === "object" && Object.key
  *  `crop` saved before the field declared crops (under `aspect`) is the first crop's when its ratio is the first's
  *  within 1%, else ignored. The first crop's cut is the image's. */
 /** A stored crop counts only at the ratio its field declares now, within 1%: a ratio changed in code makes it follow
- *  the hotspot at the new one, so the box, the cut and the crop window agree (the final review of plan (c)). */
+ *  the hotspot at the new one, so the box, the cut and the crop window agree. */
 const atRatio = (crop, ratio, imageAspect) => Math.abs(cropAspect(crop, imageAspect) / parseAspect(ratio) - 1) <= 0.01;
 /** A named crop's framed rectangle, or undefined when it follows the hotspot: its stored entry, or for the first crop a
  *  `crop` saved under `aspect`, at the crop's ratio (spec §6; the resolver and the crop window agree). */

package/dist/member-store.d.ts

@@ -1,42 +1,13 @@
-import type { MemberRole } from "./permissions.ts";
 export type MemberRecord = {
     userId: string;
     email: string | null;
     role: string;
 };
-export type InviteInput = {
-    email: string;
-    role: MemberRole;
-    redirectTo: string;
-};
-/** `invited` false = the email already had a confirmed account, so no mail was sent; the row was added. (A pending invitee is re-invited: same account, mail again, `invited` true.) */
-export type InviteResult = {
-    member: MemberRecord;
-    invited: boolean;
-};
 export interface MemberStore {
     /** Every member of the current space, by email then user id. */
     list(): Promise<MemberRecord[]>;
-    /** The space's console URL when the control plane manages its members; null in self-host. */
-    consoleUrl(): Promise<string | null>;
-    /** Creates or finds the Auth user for the email, mails the invite when it created one, upserts the row (spec 2026-09-25 members management §3). */
-    invite(input: InviteInput): Promise<InviteResult>;
-    /** Creates the Auth user with a password (confirmed, no mail) and upserts the row — the installer's first editor, `add-admin`.
-     *  An existing account keeps its password and only gains the membership. */
-    createAccount(input: {
-        email: string;
-        password: string;
-        role: MemberRole;
-    }): Promise<MemberRecord>;
-    setRole(userId: string, role: MemberRole): Promise<MemberRecord>;
-    /** Deletes the member row only; the Auth account stays. */
-    remove(userId: string): Promise<void>;
     /** The whole list at once, as the management API sets it (spec 2026-10-16 the control plane §3). */
     replaceAll(members: MemberRecord[]): Promise<void>;
 }
-export declare const memberErrors: {
-    notFound: (userId: string) => Error;
-    managed: () => Error;
-};
 /** Email first (case-insensitive), rows without one last, ties by user id. */
 export declare function sortMembers(rows: MemberRecord[]): MemberRecord[];

package/dist/member-store.js

@@ -1,7 +1,3 @@
-export const memberErrors = {
-    notFound: (userId) => new Error(`smoodly: no member "${userId}".`),
-    managed: () => new Error("smoodly: members are managed at smoodly.io."),
-};
 /** Email first (case-insensitive), rows without one last, ties by user id. */
 export function sortMembers(rows) {
     return [...rows].sort((a, b) => {

package/dist/paths.d.ts

@@ -102,7 +102,7 @@ export declare function collectionSegment(path: string | Record<string, string>
  * it is a non-empty string — absent, null, or `""` all mean "no URL".
  * There is no sibling-slug index: sibling uniqueness is the primary key
  * of `paths` plus the pre-check each store makes per locale before it
- * writes (spec 2026-09-06 §12), so Postgres and memory agree on which
+ * writes (spec 2026-09-06 §12), so every store agrees on which
  * entries can collide. */
 export declare const slugOf: (fields: Record<string, unknown>) => string | null;
 /** The entry's segment in one locale: its row's slug. An absent locale