smoodly 0.0.37 → 0.0.38

package/dist/content/node.js

@@ -0,0 +1,10 @@
+import { newNodeId } from "../admin/tree-ops.js";
+export function node(section, fields, options = {}) {
+    const type = section.schema.name;
+    return {
+        id: options.id ?? newNodeId(type),
+        type,
+        fields: fields,
+        ...(options.settings ? { settings: options.settings } : {}),
+    };
+}

package/dist/env.d.ts

@@ -4,17 +4,20 @@ export type SmoodlyEnv = {
     url: string;
     /** Server-only: the service-role key (self-host) or the environment's write key (cloud). */
     secretKey: string;
-    /** What a browser may hold for the content project: anon/publishable key, or the cloud's per-environment key. It reads no content (sign-in and presence only). */
+    /** What a browser may hold for the content project: anon/publishable key, or the cloud's per-environment key. It reads no content (sign-in and presence only). "" on a live site that runs without the admin. */
     publishableKey: string;
     /** Where editors sign in. Defaults to `url`. */
     authUrl: string;
     /** That project's publishable key. Defaults to `publishableKey`. */
     authKey: string;
 };
-export declare function resolveSmoodlyEnv(env: Record<string, string | undefined>): SmoodlyEnv;
+/** The live site reads with the URL and the secret key; the admin and presence also need the
+ *  publishable key, so their callers pass "admin" (spec 2026-09-30 tester findings §4). A key
+ *  in the wrong variable or of no known form is named here, not by a failed read later. */
+export declare function resolveSmoodlyEnv(env: Record<string, string | undefined>, need?: "site" | "admin"): SmoodlyEnv;
 /** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
  *  so `next build` without env still succeeds. */
-export declare const smoodlyEnv: () => SmoodlyEnv;
+export declare const smoodlyEnv: (need?: "site" | "admin") => SmoodlyEnv;
 /** What the browser needs to join the admin's presence channel: the content project's URL, publishable key and space, public values only — never for content reads (spec 2026-09-29 content API contract §8). */
 export type PresenceConfig = {
     url: string;

package/dist/env.js

@@ -1,27 +1,51 @@
 // The one config shape (spec 2026-09-04 §4/§6). Self-host sets three
-// names; the cloud sets five. The two defaults are what keep a single
+// names (the live site alone needs two); the cloud sets five. The two defaults are what keep a single
 // code path: a default for an absent value is not a mode branch.
 import { createSmoodlyClient } from "./client.js";
 import { readCurrentSpace } from "./current-space.js";
-const REQUIRED = ["SMOODLY_URL", "SMOODLY_SECRET_KEY", "SMOODLY_PUBLISHABLE_KEY"];
-export function resolveSmoodlyEnv(env) {
-    const missing = REQUIRED.filter((name) => !env[name]);
-    if (missing.length > 0) {
-        throw new Error(`smoodly: set ${missing.join(", ")} — see .env.local.example.`);
+const SITE_NEEDS = ["SMOODLY_URL", "SMOODLY_SECRET_KEY"];
+const ADMIN_NEEDS = [...SITE_NEEDS, "SMOODLY_PUBLISHABLE_KEY"];
+const DEPLOYING = "https://smoodly.io/docs/getting-started/deploying";
+const isJwt = (v) => v.split(".").length === 3;
+/** A legacy JWT key's role claim ("anon", "service_role"; "authenticated" for a cloud space key); null when it cannot be read. */
+function jwtRole(v) {
+    if (!isJwt(v))
+        return null;
+    try {
+        const role = JSON.parse(atob(v.split(".")[1].replace(/-/g, "+").replace(/_/g, "/"))).role;
+        return typeof role === "string" ? role : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The live site reads with the URL and the secret key; the admin and presence also need the
+ *  publishable key, so their callers pass "admin" (spec 2026-09-30 tester findings §4). A key
+ *  in the wrong variable or of no known form is named here, not by a failed read later. */
+export function resolveSmoodlyEnv(env, need = "site") {
+    const missing = (need === "admin" ? ADMIN_NEEDS : SITE_NEEDS).filter((name) => !env[name]);
+    if (missing.length > 0)
+        throw new Error(`smoodly: set ${missing.join(", ")} in .env.local (Deploying: ${DEPLOYING}).`);
+    const secretKey = env.SMOODLY_SECRET_KEY;
+    const publishableKey = env.SMOODLY_PUBLISHABLE_KEY ?? "";
+    if (secretKey.startsWith("sb_publishable_") || jwtRole(secretKey) === "anon") {
+        throw new Error("smoodly: SMOODLY_SECRET_KEY holds a publishable key — copy the secret (service-role) key from your Supabase project.");
+    }
+    if (!secretKey.startsWith("sb_secret_") && !isJwt(secretKey)) {
+        throw new Error("smoodly: SMOODLY_SECRET_KEY is neither an sb_secret_ key nor a JWT — copy the secret (service-role) key from your Supabase project.");
+    }
+    if (publishableKey.startsWith("sb_secret_") || jwtRole(publishableKey) === "service_role") {
+        throw new Error("smoodly: SMOODLY_PUBLISHABLE_KEY holds a secret key — it reaches the browser; copy the publishable (anon) key from your Supabase project.");
+    }
+    if (publishableKey && !publishableKey.startsWith("sb_publishable_") && !isJwt(publishableKey)) {
+        throw new Error("smoodly: SMOODLY_PUBLISHABLE_KEY is neither an sb_publishable_ key nor a JWT — copy the publishable (anon) key from your Supabase project.");
     }
     const url = env.SMOODLY_URL;
-    const publishableKey = env.SMOODLY_PUBLISHABLE_KEY;
-    return {
-        url,
-        secretKey: env.SMOODLY_SECRET_KEY,
-        publishableKey,
-        authUrl: env.SMOODLY_AUTH_URL || url,
-        authKey: env.SMOODLY_AUTH_KEY || publishableKey,
-    };
+    return { url, secretKey, publishableKey, authUrl: env.SMOODLY_AUTH_URL || url, authKey: env.SMOODLY_AUTH_KEY || publishableKey };
 }
 /** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
  *  so `next build` without env still succeeds. */
-export const smoodlyEnv = () => resolveSmoodlyEnv(process.env);
+export const smoodlyEnv = (need = "site") => resolveSmoodlyEnv(process.env, need);
 /** One lookup per process per content project and key: the space never
  *  changes for a key. A failed lookup is not cached, so the next call retries. */
 const spaces = new Map();

package/dist/index.d.ts

@@ -66,7 +66,8 @@ export type { PageStore, PageRecord, PageLocale, PageVersion, PageScan, PageStor
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.ts";
 export type { SmoodlyConfig, ResolvedConfig } from "./config.ts";
 export type { FieldBuilder, Descriptor, ValueOf, Option, OptionInput, OptionValue } from "./fields.ts";
-export type { SectionSchema, ElementSchema, BuilderMap, Values } from "./schema.ts";
+export type { SectionSchema, ElementSchema, BuilderMap, Values, StoredValues } from "./schema.ts";
+export { node } from "./content/node.ts";
 export type { CollectionSeo } from "./seo.ts";
 export type { EntryRef, EntryItem, PageItem, GlobalItem, VisualGlobalItem, Seo } from "./read-shapes.ts";
 export type { RefTo } from "./fields.ts";
@@ -97,7 +98,7 @@ export declare const smoodly: {
                 omit: string[];
             };
             css?: false;
-            sample?: Partial<{ [K in keyof import("./schema.ts").NamespaceValues<F>]: import("./schema.ts").NamespaceValues<F>[K] extends import("./fields.ts").RefTo<any, any> ? string : import("./schema.ts").NamespaceValues<F>[K] extends import("./fields.ts").RefTo<any, any>[] ? string[] : import("./schema.ts").NamespaceValues<F>[K]; } & { [K_1 in keyof import("./schema.ts").NamespaceValues<S>]: import("./schema.ts").NamespaceValues<S>[K_1] extends import("./fields.ts").RefTo<any, any> ? string : import("./schema.ts").NamespaceValues<S>[K_1] extends import("./fields.ts").RefTo<any, any>[] ? string[] : import("./schema.ts").NamespaceValues<S>[K_1]; }> | undefined;
+            sample?: Partial<import("./schema.ts").StoredValues<F> & import("./schema.ts").StoredValues<S>> | undefined;
         }): import("./schema.ts").SectionSchema<F, S>;
         element<F extends import("./schema.ts").BuilderMap = {}, S extends import("./schema.ts").BuilderMap = {}>(input: {
             name: string;
@@ -111,7 +112,7 @@ export declare const smoodly: {
                 omit: string[];
             };
             css?: false;
-            sample?: Partial<{ [K in keyof import("./schema.ts").NamespaceValues<F>]: import("./schema.ts").NamespaceValues<F>[K] extends import("./fields.ts").RefTo<any, any> ? string : import("./schema.ts").NamespaceValues<F>[K] extends import("./fields.ts").RefTo<any, any>[] ? string[] : import("./schema.ts").NamespaceValues<F>[K]; } & { [K_1 in keyof import("./schema.ts").NamespaceValues<S>]: import("./schema.ts").NamespaceValues<S>[K_1] extends import("./fields.ts").RefTo<any, any> ? string : import("./schema.ts").NamespaceValues<S>[K_1] extends import("./fields.ts").RefTo<any, any>[] ? string[] : import("./schema.ts").NamespaceValues<S>[K_1]; }> | undefined;
+            sample?: Partial<import("./schema.ts").StoredValues<F> & import("./schema.ts").StoredValues<S>> | undefined;
         } & {
             contexts: ("richtext" | "column")[];
         }): import("./schema.ts").ElementSchema<F, S>;

package/dist/index.js

@@ -46,6 +46,7 @@ export { fixedPathFor } from "./localize.js";
 export { addressMap, assertAddress, codeAddresses, collectionKey, lastPart, ownerCollection, pageKey } from "./addresses.js";
 export { anchorUrl, anchorsFor, candidates, fullPath, pickHit } from "./anchors.js";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.js";
+export { node } from "./content/node.js";
 export { DEFAULT_TOOLSET } from "./toolset.js";
 export { collectionOrder, collectionDepth, DEFAULT_ORDER } from "./collections.js";
 export { GLOBAL_NODE_TYPE, SETTINGS_KEY, STYLES_KEY, CSS_KEY, globalLink } from "./global.js";

package/dist/member-store.d.ts

@@ -21,6 +21,13 @@ export interface MemberStore {
     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>;
@@ -44,6 +51,11 @@ export declare class MemoryMemberStore implements MemberStore {
     list(): Promise<MemberRecord[]>;
     consoleUrl(): Promise<string | null>;
     invite(input: InviteInput): Promise<InviteResult>;
+    createAccount(input: {
+        email: string;
+        password: string;
+        role: MemberRole;
+    }): Promise<MemberRecord>;
     setRole(userId: string, role: MemberRole): Promise<MemberRecord>;
     remove(userId: string): Promise<void>;
 }

package/dist/member-store.js

@@ -44,6 +44,14 @@ export class MemoryMemberStore {
         this.rows = [...this.rows.filter((r) => r.userId !== userId), member];
         return { member, invited };
     }
+    async createAccount(input) {
+        const key = input.email.toLowerCase();
+        const userId = this.accounts[key] ?? this.rows.find((r) => r.email?.toLowerCase() === key)?.userId ?? crypto.randomUUID();
+        this.accounts[key] = userId;
+        const member = { userId, email: input.email, role: input.role };
+        this.rows = [...this.rows.filter((r) => r.userId !== userId), member];
+        return member;
+    }
     async setRole(userId, role) {
         const row = this.rows.find((r) => r.userId === userId);
         if (!row)

package/dist/model-key.d.ts

@@ -0,0 +1 @@
+export declare function modelKey(model: unknown): string;

package/dist/model-key.js

@@ -0,0 +1,36 @@
+// A short, stable hash of the registered model (spec 2026-09-30 tester findings §3):
+// object keys sorted, functions dropped, cycles cut — two processes agree.
+// Plain arithmetic, no node:crypto: the root entry is imported by client sections too.
+function canonical(value, seen) {
+    if (typeof value === "function" || value === undefined)
+        return undefined;
+    if (value === null || typeof value !== "object")
+        return value;
+    if (seen.has(value))
+        return "[cycle]";
+    seen.add(value);
+    const out = Array.isArray(value)
+        ? value.map((v) => canonical(v, seen) ?? null)
+        : Object.fromEntries(Object.keys(value).sort().flatMap((k) => {
+            const v = canonical(value[k], seen);
+            return v === undefined ? [] : [[k, v]];
+        }));
+    seen.delete(value);
+    return out;
+}
+/** Two 32-bit FNV-1a style runs with different seeds (cyrb53's mixing): 64 bits, of which 48 are kept. */
+function hash(text) {
+    let h1 = 0xdeadbeef, h2 = 0x41c6ce57;
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        h1 = Math.imul(h1 ^ c, 2654435761);
+        h2 = Math.imul(h2 ^ c, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    const hex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+    return (hex(h2) + hex(h1)).slice(0, 12);
+}
+export function modelKey(model) {
+    return hash(JSON.stringify(canonical(model, new WeakSet())));
+}

package/dist/next/page-renderer.js

@@ -39,7 +39,7 @@ export function createPageRenderer(options) {
         // Keyed by what the unit holds, not only where: an address that changes
         // owner — a deploy handing it to a code record, which fires no tag —
         // can never serve the previous occupant (spec 2026-09-29 pre-install fixes §5).
-        return unstable_cache(() => site.load(target, locale, path), ["smoodly-site", locale, path, target.kind, target.id], {
+        return unstable_cache(() => site.load(target, locale, path), ["smoodly-site", site.cacheKey, locale, path, target.kind, target.id], {
             tags: [target.kind === "page" ? pageTag(target.id) : entryTag(target.id)],
         })();
     }
@@ -114,7 +114,8 @@ export function createPageRenderer(options) {
         const target = await site.locate(locale, path);
         if (target?.redirect)
             await redirectTo(target, locale, params);
-        const hit = target ? await load(target, locale, path, draft, version) : null;
+        // A code-owned address with no record yet is served from code (spec 2026-09-30 tester findings §2).
+        const hit = target ? await load(target, locale, path, draft, version) : site.codePage(locale, path);
         if (!hit || !accept(hit))
             notFound();
         // The draft marker tells the page editor's canvas diagnosis that Smoodly
@@ -129,9 +130,9 @@ export function createPageRenderer(options) {
         const path = pathFor(locale);
         const { isEnabled: draft } = await draftMode();
         const target = await site.locate(locale, path);
-        if (!target || target.redirect)
+        if (target?.redirect)
             return {};
-        const hit = await load(target, locale, path, draft);
+        const hit = target ? await load(target, locale, path, draft) : site.codePage(locale, path);
         if (!hit || !accept(hit))
             return {};
         // A page type without seo: true still gets its page title as <title>; seo: true adds the panel's values on top.
@@ -153,7 +154,7 @@ export function createPageRenderer(options) {
         const { isEnabled: draft } = await draftMode();
         if (draft)
             return site.getGlobal(item, { locale, draft: true });
-        return unstable_cache(() => site.getGlobal(item, { locale }), ["smoodly-global", item.name, locale], {
+        return unstable_cache(() => site.getGlobal(item, { locale }), ["smoodly-global", site.cacheKey, item.name, locale], {
             tags: [globalTag(item.name)],
         })();
     }

package/dist/next/queries.js

@@ -36,7 +36,7 @@ export function createSmoodlyQueries(options) {
         const { isEnabled: draft } = await draftMode();
         if (draft)
             return read(true);
-        return unstable_cache(() => read(false), ["smoodly-q", ...key], { tags })();
+        return unstable_cache(() => read(false), ["smoodly-q", site.cacheKey, ...key], { tags })();
     }
     /** The tag needs the id: a path is located first, uncached, as the renderer does. */
     async function idOf(kind, locale, pathOrId) {

package/dist/schema-read.d.ts

@@ -0,0 +1,7 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+/** The policies show `smoodly_meta` to a write key only, so no visible row means the key is not a secret key (spec §5). */
+export declare function readSchemaVersion(db: SupabaseClient): Promise<{
+    version: number;
+} | {
+    missing: "key" | "schema";
+}>;

package/dist/schema-read.js

@@ -0,0 +1,15 @@
+import { SCHEMA_VERSION_KEY } from "./schema-version.js";
+/** The policies show `smoodly_meta` to a write key only, so no visible row means the key is not a secret key (spec §5). */
+export async function readSchemaVersion(db) {
+    const res = await db.from("smoodly_meta").select("value").eq("key", SCHEMA_VERSION_KEY).maybeSingle();
+    if (res.error) {
+        // PGRST205: not in PostgREST's schema cache; 42P01: undefined table; 42501: no grant.
+        if (res.error.code === "PGRST205" || res.error.code === "42P01")
+            return { missing: "schema" };
+        if (res.error.code === "42501")
+            return { missing: "key" };
+        throw new Error(`smoodly: reading the schema version: ${res.error.message}`);
+    }
+    const n = Number(res.data?.value);
+    return res.data && Number.isInteger(n) ? { version: n } : { missing: "key" };
+}

package/dist/schema-version.d.ts

@@ -15,3 +15,5 @@ export declare function schemaVersionSQL(version: number): string;
  *  bump, and is fine. */
 export declare const schemaBehind: (database: number | null, required?: number) => boolean;
 export declare function schemaBehindMessage(database: number | null, required?: number): string;
+/** The version row is hidden from anything but a secret key, so an invisible row means the wrong key, not an old schema. */
+export declare const secretKeyRefusedMessage = "smoodly: SMOODLY_SECRET_KEY cannot read the schema version \u2014 it is not the project's secret (service-role) key; the publishable key there is the usual mix-up.";

package/dist/schema-version.js

@@ -28,5 +28,7 @@ export function schemaVersionSQL(version) {
 export const schemaBehind = (database, required = SCHEMA_VERSION) => database === null || database < required;
 export function schemaBehindMessage(database, required = SCHEMA_VERSION) {
     return (`smoodly: the database schema is at version ${database ?? "none"}; this Smoodly needs version ${required}. ` +
-        "Run `npx smoodly migrate`, then `supabase db push` (hosted) or `supabase db reset` (local).");
+        "Run `npx smoodly migrate`, then apply it: `supabase db push` (hosted) or `supabase migration up` (local).");
 }
+/** The version row is hidden from anything but a secret key, so an invisible row means the wrong key, not an old schema. */
+export const secretKeyRefusedMessage = "smoodly: SMOODLY_SECRET_KEY cannot read the schema version — it is not the project's secret (service-role) key; the publishable key there is the usual mix-up.";

package/dist/schema.d.ts

@@ -2,6 +2,7 @@ import { type Descriptor, type FieldBuilder, type ValueOf } from "./fields.ts";
 import { pageSchema } from "./page.ts";
 import type { RefTo } from "./fields.ts";
 import type { EntryRef } from "./read-shapes.ts";
+import type { FileValue, ImageValue, ResolvedFile, ResolvedImage, ResolvedVideo, VideoValue } from "./media.ts";
 export type BuilderMap = Record<string, FieldBuilder<any, any>>;
 export type SectionSchema<F extends BuilderMap = BuilderMap, S extends BuilderMap = BuilderMap> = {
     kind: "section";
@@ -54,9 +55,14 @@ export type Materialize<V> = V extends RefTo<infer T, infer M> ? EntryRef<ShapeO
 export type Values<M extends BuilderMap> = {
     [K in keyof NamespaceValues<M>]: Materialize<NamespaceValues<M>[K]>;
 };
-/** A sample stores ids where a read shows references. */
-type Stored<M extends BuilderMap> = {
-    [K in keyof NamespaceValues<M>]: NamespaceValues<M>[K] extends RefTo<any, any> ? string : NamespaceValues<M>[K] extends RefTo<any, any>[] ? string[] : NamespaceValues<M>[K];
+/** One value as storage holds it: a ref is the entry's id, media is the `{ asset }` value, and lists and
+ *  objects hold the same inside. Richtext (`unknown`) and scalars pass through. */
+export type StoredOf<V> = unknown extends V ? V : V extends RefTo<any, any> ? string : V extends ResolvedImage ? ImageValue : V extends ResolvedVideo ? VideoValue : V extends ResolvedFile ? FileValue : V extends readonly (infer I)[] ? StoredOf<I>[] : V extends Record<string, unknown> ? {
+    [K in keyof V]: StoredOf<V[K]>;
+} : V;
+/** What storage holds for a field map (a sample, a node built from code). */
+export type StoredValues<M extends BuilderMap> = {
+    [K in keyof NamespaceValues<M>]: StoredOf<NamespaceValues<M>[K]>;
 };
 type SectionInput<F extends BuilderMap, S extends BuilderMap> = {
     name: string;
@@ -71,7 +77,7 @@ type SectionInput<F extends BuilderMap, S extends BuilderMap> = {
         omit: string[];
     };
     css?: false;
-    sample?: Partial<Stored<F> & Stored<S>>;
+    sample?: Partial<StoredValues<F> & StoredValues<S>>;
 };
 export declare const schema: {
     page: typeof pageSchema;

package/dist/site.d.ts

@@ -108,6 +108,9 @@ export type LoadOptions = {
 export interface SmoodlySite {
     readonly locales: LocaleSet;
     readonly homePageSlug: string;
+    /** The package version and a hash of the registered model: a part of every cache key, so an upgrade or a
+     *  model change never serves a unit cached in the old shape (spec 2026-09-30 tester findings §3). */
+    readonly cacheKey: string;
     /** The resolved styles values the renderer and `getGlobal` hand the wrapper. */
     readonly styles: StyleValues;
     /** The custom section's resolved options the renderer hands renderPage. */
@@ -119,6 +122,11 @@ export interface SmoodlySite {
     /** Everything the renderer needs for one target: null when it is a folder, unpublished (outside draft), or gone. */
     load(target: PathTarget, locale: string, path: string, options?: LoadOptions): Promise<SiteHit | null>;
     resolve(locale: string, path: string, options?: LoadOptions): Promise<SiteHit | null>;
+    /** A fixed page type (or a collection's index page) as code alone describes it, when `path` is its address in
+     *  `locale`: an empty tree, the page fields' defaults, the registration's title. The renderer serves it where
+     *  the index has no row — a page type added after install, a locale added to the config — until the admin
+     *  makes the record (spec 2026-09-30 tester findings §2). Not in `getPagesTree`: that lists records. */
+    codePage(locale: string, path: string): SitePage | null;
     getPagesTree(options?: {
         locale?: string;
         draft?: boolean;

package/dist/site.js

@@ -6,9 +6,11 @@ import { globalNodeId, SETTINGS_KEY, STYLES_KEY, CSS_KEY } from "./global.js";
 import { SMD_KEY } from "./section-wrapper.js";
 import { resolveStyleValues } from "./styles.js";
 import { resolveCustom } from "./custom/index.js";
-import { addressMap, codeAddresses } from "./addresses.js";
+import { addressMap, codeAddresses, lastPart } from "./addresses.js";
 import { fullPath, servedAnchor } from "./anchors.js";
 import { withDefaults } from "./field-defaults.js";
+import { modelKey } from "./model-key.js";
+import { SMOODLY_VERSION } from "./version.js";
 import { toEntryItem, toPageItem } from "./read-shapes.js";
 import { entrySeo, pageSeo, SEO_KEY } from "./seo.js";
 /** The `page` prop for a loaded page. `href` is the app's seam from a
@@ -36,11 +38,22 @@ export function createSmoodlySite(options) {
     const custom = resolveCustom(options.custom);
     const elements = elementSchemas(options.elements);
     // Code-owned addresses from the site's own registry (spec 2026-09-29 nested paths §3): a code-owned root's path.
-    const addresses = addressMap(codeAddresses({ locales, pages: options.pages, collections: options.collections }));
+    const codeOwned = codeAddresses({ locales, pages: options.pages, collections: options.collections });
+    const addresses = addressMap(codeOwned);
     const pathOpts = { locales, homePageSlug, addresses };
     /** The same addresses as the path index sees them: an entry's stored part joined to its collection's (spec 2026-09-29 anchored paths §2). */
     const anchors = { addresses, homePageSlug, defaultLocale: locales.default };
     const mounted = options.collections.filter((c) => c.path !== undefined);
+    // Every cached read keys on it (spec 2026-09-30 tester findings §3): an upgrade or a model change starts a fresh cache.
+    const cacheKey = `${SMOODLY_VERSION}:${modelKey({
+        // Whole schemas: a collection's order, tree or title field changes a read as its fields do (functions drop out in the hash).
+        collections: options.collections,
+        globals: (options.globals ?? []).map((g) => ({ name: g.name, fields: g.fields, section: g.section })),
+        sections: options.sections.map((x) => ("schema" in x ? x.schema : x)),
+        elements: (options.elements ?? []).map((x) => ("schema" in x ? x.schema : x)),
+        pages: options.pages.map((x) => x.schema),
+        locales, homePageSlug, styles, custom,
+    })}`;
     /** The resolver's fetcher, bound to a locale: the merged fields of that
      *  locale — published ones (a versioned collection's snapshot) on the
      *  public path, the live rows in draft mode. */
@@ -336,9 +349,33 @@ export function createSmoodlySite(options) {
             };
         },
     };
+    const codePath = (address) => (address === homePageSlug ? "/" : `/${address}`);
+    function codePage(locale, path) {
+        const spec = codeOwned.find((a) => a.template !== null && a.segments[locale] !== undefined && codePath(a.segments[locale]) === path);
+        if (!spec || !locales.supported.includes(locale))
+            return null;
+        const template = spec.template;
+        const withSeo = options.pages.some((x) => x.schema.kind === "page" && x.schema.name === template && x.schema.seo === true);
+        return {
+            kind: "page",
+            locale,
+            // No record yet: the id only has to be stable and never a stored one.
+            record: { id: `code:${template}`, parentId: null, template, fixed: spec.key, locales: {}, sort: null },
+            template,
+            tree: { zones: {} },
+            title: spec.title,
+            path,
+            fields: withDefaults(undefined, pageFields(template)),
+            ancestors: [],
+            children: [],
+            locales: Object.fromEntries(Object.entries(spec.segments).map(([l, address]) => [l, { slug: lastPart(address), path: codePath(address) }])),
+            ...(withSeo ? { seo: pageSeo(undefined, spec.title) } : {}),
+        };
+    }
     const site = {
         locales,
         homePageSlug,
+        cacheKey,
         styles,
         custom,
         locate: (locale, path) => options.stores().pages.resolvePath(locale, path),
@@ -352,6 +389,7 @@ export function createSmoodlySite(options) {
             const target = await site.locate(locale, path);
             return target && !target.redirect ? site.load(target, locale, path, opts) : null;
         },
+        codePage,
         ...api,
     };
     return site;

package/dist/supabase-member-store.d.ts

@@ -10,6 +10,12 @@ export declare class SupabaseMemberStore implements MemberStore {
     /** The admin API has no lookup by email: page through the users (tens, not thousands). */
     private userIdByEmail;
     invite(input: InviteInput): Promise<InviteResult>;
+    private upsertRow;
+    createAccount(input: {
+        email: string;
+        password: string;
+        role: MemberRole;
+    }): Promise<MemberRecord>;
     setRole(userId: string, role: MemberRole): Promise<MemberRecord>;
     remove(userId: string): Promise<void>;
 }

package/dist/supabase-member-store.js

@@ -51,14 +51,32 @@ export class SupabaseMemberStore {
         else {
             throw new Error(`smoodly: ${sent.error.message}`);
         }
+        return { member: await this.upsertRow(userId, input.email, input.role), invited };
+    }
+    async upsertRow(userId, email, role) {
         const res = await this.db
             .from("members")
-            .upsert({ user_id: userId, email: input.email, role: input.role }, { onConflict: "space_id,user_id" })
+            .upsert({ user_id: userId, email, role }, { onConflict: "space_id,user_id" })
             .select("user_id, email, role")
             .single();
         if (res.error)
             throw new Error(`smoodly: ${res.error.message}`);
-        return { member: this.toRecord(res.data), invited };
+        return this.toRecord(res.data);
+    }
+    async createAccount(input) {
+        const created = await this.db.auth.admin.createUser({ email: input.email, password: input.password, email_confirm: true });
+        let userId;
+        if (!created.error) {
+            userId = created.data.user.id;
+        }
+        else if (created.error.code === "email_exists" || /already (been )?registered/i.test(created.error.message)) {
+            // An existing account keeps its password; it only gains the membership.
+            userId = await this.userIdByEmail(input.email);
+        }
+        else {
+            throw new Error(`smoodly: ${created.error.message}`);
+        }
+        return this.upsertRow(userId, input.email, input.role);
     }
     async setRole(userId, role) {
         const res = await this.db.from("members").update({ role }).eq("user_id", userId).select("user_id, email, role").maybeSingle();

package/dist/supabase-store.js

@@ -8,7 +8,8 @@
 // rewritten through ONE RPC per write, so a collision rolls back.
 import { assertPublishable, assertSupportedLocale, localeRow, pageErrors, pageRefEdges, pathOptions, refSections, storeAnchors, } from "./store.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
-import { SCHEMA_VERSION_KEY, schemaBehind, schemaBehindMessage } from "./schema-version.js";
+import { schemaBehind, schemaBehindMessage, secretKeyRefusedMessage } from "./schema-version.js";
+import { readSchemaVersion } from "./schema-read.js";
 import { groupRedirects } from "./store.js";
 import { assertFresh, draftToken, StaleDraftError } from "./draft-token.js";
 import { assertDepth, assertSegment, isHomeNode, pagePathRows, rewriteTargets } from "./paths.js";
@@ -381,25 +382,26 @@ export class SupabasePageStore {
     resolvePath(locale, path) {
         if (!this.schemaChecked) {
             this.schemaChecked = true;
-            void this.schemaVersion()
-                .then((v) => {
-                if (schemaBehind(v))
-                    console.warn(schemaBehindMessage(v));
+            // Once per store: a wrong key is named as a wrong key, not as an old schema (spec 2026-09-30 tester findings §4).
+            void readSchemaVersion(this.db)
+                .then((read) => {
+                if ("missing" in read)
+                    console.warn(read.missing === "key" ? secretKeyRefusedMessage : schemaBehindMessage(null));
+                else if (schemaBehind(read.version))
+                    console.warn(schemaBehindMessage(read.version));
             })
                 .catch(() => { });
         }
         return this.paths.resolve(locale, path);
     }
     async schemaVersion() {
-        const res = await this.db.from("smoodly_meta").select("value").eq("key", SCHEMA_VERSION_KEY).maybeSingle();
-        if (res.error) {
-            // PGRST205: not in PostgREST's schema cache; 42P01: undefined table.
-            if (res.error.code === "PGRST205" || res.error.code === "42P01")
-                return null;
-            this.fail(res.error.message);
-        }
-        const n = Number(res.data?.value);
-        return Number.isInteger(n) ? n : null;
+        const read = await readSchemaVersion(this.db);
+        if ("version" in read)
+            return read.version;
+        // The table exists and the row is hidden: the key is not a secret key.
+        if (read.missing === "key")
+            throw new Error(secretKeyRefusedMessage);
+        return null;
     }
     pathsOf(id) {
         return UUID_RE.test(id) ? this.paths.pathsOf({ kind: "page", id }) : Promise.resolve({});

package/dist/tags.d.ts

@@ -17,3 +17,6 @@ export declare function addTags(current: readonly string[], input: string, opts?
  *  entries disagree on a tag's casing the most used one wins, a tie going to plain string
  *  order — never to the order the values arrived in, which is the store's business. */
 export declare function distinctTags(values: readonly unknown[]): string[];
+/** A tags value as stored (spec 2026-09-30 tester findings §5): normalized, one per
+ *  case-folded tag, each taking the spelling already used in the collection. */
+export declare function canonicalTags(values: readonly unknown[], known: readonly string[]): string[];

package/dist/tags.js

@@ -48,3 +48,19 @@ export function distinctTags(values) {
     const pick = (counts) => [...counts].sort(([a, n], [b, m]) => m - n || (a < b ? -1 : 1))[0][0];
     return [...variants.values()].map(pick).sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
 }
+/** A tags value as stored (spec 2026-09-30 tester findings §5): normalized, one per
+ *  case-folded tag, each taking the spelling already used in the collection. */
+export function canonicalTags(values, known) {
+    const out = [];
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const typed = normalizeTag(value);
+        if (typed === "")
+            continue;
+        const tag = known.find((k) => sameTag(k, typed)) ?? typed;
+        if (!out.some((t) => sameTag(t, tag)))
+            out.push(tag);
+    }
+    return out;
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SMOODLY_VERSION = "0.0.38";

package/dist/version.js

@@ -0,0 +1,2 @@
+// Generated by scripts/write-version.mjs from package.json — do not edit.
+export const SMOODLY_VERSION = "0.0.38";