smoodly 0.0.51 → 0.0.52

package/dist/cli/migrate.js

@@ -1,138 +0,0 @@
-// packages/smoodly/src/cli/migrate.ts
-// The filesystem half of `smoodly migrate` (spec 2026-09-26 §2): reads
-// the package's migrations/ and the app's supabase/migrations/, loads the
-// app's collections, asks the pure planner (../migrations.ts) what to
-// write, writes it. The message strings are what the docs quote.
-import { existsSync } from "node:fs";
-import { readdir, readFile, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { collectionSQL } from "../sql.js";
-import { coreFileVersion, SCHEMA_VERSION, secretKeyRefusedMessage } from "../schema-version.js";
-import { readSchemaVersion } from "../schema-read.js";
-import { createSmoodlyClient } from "../client.js";
-import { resolveSmoodlyEnv } from "../env.js";
-import { loadAppEnv } from "./space-io.js";
-import { planIsEmpty, planMigrate } from "../migrations.js";
-import { loadCollections } from "./load-collections.js";
-import { loadConfig } from "./load-config.js";
-import { siteOptions } from "../bind.js";
-import { documentStamp } from "../document-stamp.js";
-import { SupabasePublishedStore } from "../supabase-published-store.js";
-export const DEFAULT_COLLECTIONS = "smoodly/collections.ts";
-/** The Astro starter keeps the setup under src/ (plan 2026-10-06 astro adapter 3); the default follows it when the Next path is absent. */
-export function collectionsFile(cwd, given, exists = existsSync) {
-    if (given !== DEFAULT_COLLECTIONS || exists(resolve(cwd, given)))
-        return given;
-    return exists(resolve(cwd, "src/smoodly/collections.ts")) ? "src/smoodly/collections.ts" : given;
-}
-/** The folder shipped in the package: `../../migrations/` from dist/cli/ and from src/cli/ alike. */
-export const PACKAGE_MIGRATIONS_DIR = fileURLToPath(new URL("../../migrations/", import.meta.url));
-export const NO_FOLDER = (dir) => `No supabase/migrations folder here (${dir}) — nothing to do. Run it in your app's folder, or pass --migrations. (Smoodly Cloud keeps the schema current; a self-host app gets the folder from \`supabase init\`.)`;
-export const NEXT_STEP = "Next: apply it — `supabase db push` (hosted) or `supabase migration up` (local).";
-export const upToDate = (version, n) => `Up to date: core schema v${version}, every collection's view is current (${n} ${n === 1 ? "collection" : "collections"}).`;
-export const KEY_NOT_CHECKED = "Key not checked: SMOODLY_URL and SMOODLY_SECRET_KEY are not both set here.";
-export const keyChecked = (version) => `SMOODLY_SECRET_KEY reads the database (schema v${version}).`;
-export const modifiedMessage = (name) => `Refusing: ${name} differs from the package's copy. A published migration is never edited — restore it from the package, or move your change to a new file.`;
-export async function readSqlFiles(dir) {
-    const names = (await readdir(dir)).filter((n) => n.endsWith(".sql")).sort();
-    return Promise.all(names.map(async (name) => ({ name, text: await readFile(join(dir, name), "utf8") })));
-}
-/** One line per thing the plan does; "Pending" wording under --check. */
-export function describePlan(plan, check) {
-    const lines = [];
-    for (const name of plan.modified)
-        lines.push(modifiedMessage(name));
-    for (const f of plan.copy)
-        lines.push(`${check ? "Pending" : "Copied"} ${f.name} (core schema v${coreFileVersion(f.name)}).`);
-    if (plan.views) {
-        const names = [...plan.views.text.matchAll(/^-- smoodly:collection (\S+)/gm)].map((m) => m[1]);
-        lines.push(`${check ? "Pending" : "Wrote"} ${plan.views.name} (views: ${names.join(", ")}).`);
-    }
-    return lines;
-}
-/** The delivery line of `--check` (DESIGN §3, the document stamp): a count with the one command to run, never a verdict. */
-export const deliveryLine = (d) => d.behind === 0
-    ? `Delivery: every published document is current (${d.total}).`
-    : `Delivery: ${d.behind} of ${d.total} documents are behind the current stamp — run npx smoodly rebuild.`;
-async function countDelivery(env, cwd) {
-    const config = await loadConfig(cwd);
-    const stamp = documentStamp(siteOptions(config, () => { throw new Error("smoodly: the stamp reads no store"); }));
-    const db = createSmoodlyClient(resolveSmoodlyEnv(env));
-    return new SupabasePublishedStore(db, config.registry.collections ?? []).countBehind(stamp);
-}
-/** Errors that are a verdict on the env itself, not on the network: they fail the build. */
-const ENV_VERDICT = /SMOODLY_(SECRET|PUBLISHABLE)_KEY|SMOODLY_URL "/;
-/** The build's key check (decided 2026-10-02): a key the site would be refused with fails the
- *  deploy, so the running deployment keeps serving. No key here, or no route to the database
- *  (a CI build), passes without a verdict. */
-async function checkKey(out, cwd, deps) {
-    const env = deps.env ?? process.env;
-    loadAppEnv(cwd, env);
-    if (!env.SMOODLY_URL || !env.SMOODLY_SECRET_KEY) {
-        out(KEY_NOT_CHECKED);
-        return 0;
-    }
-    let read;
-    try {
-        read = await (deps.readKey ?? ((e) => readSchemaVersion(createSmoodlyClient(resolveSmoodlyEnv(e)))))(env);
-    }
-    catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        if (ENV_VERDICT.test(message)) {
-            out(message);
-            return 1;
-        }
-        out(`Key not checked: ${message}`);
-        return 0;
-    }
-    if ("version" in read) {
-        out(keyChecked(read.version));
-        try {
-            out(deliveryLine(await (deps.delivery ?? countDelivery)(env, cwd)));
-        }
-        catch (e) {
-            out(`Delivery: not checked: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
-    else if (read.missing === "key") {
-        out(secretKeyRefusedMessage);
-        return 1;
-    }
-    else
-        out("Key not checked: the database has no Smoodly schema yet — apply the migrations before the site goes live.");
-    return 0;
-}
-export async function runMigrate(args, out, deps = {}) {
-    const cwd = deps.cwd ?? process.cwd();
-    const appDir = resolve(cwd, args.migrations);
-    if (!existsSync(appDir)) {
-        // A build that runs the check must not pass one it never made (spec 2026-09-30 tester findings §5).
-        if (args.check) {
-            out(`smoodly: no supabase/migrations here (${appDir}) — run the check in the app's folder, or pass --migrations.`);
-            return 1;
-        }
-        out(NO_FOLDER(appDir));
-        return 0;
-    }
-    const collections = await (deps.load ?? loadCollections)(resolve(cwd, collectionsFile(cwd, args.collections)), cwd);
-    const plan = planMigrate({
-        packageFiles: await readSqlFiles(PACKAGE_MIGRATIONS_DIR),
-        appFiles: await readSqlFiles(appDir),
-        collections: collections.map((c) => ({ name: c.name, sql: collectionSQL(c) })),
-    }, (deps.now ?? (() => new Date()))());
-    for (const line of describePlan(plan, args.check))
-        out(line);
-    if (plan.modified.length > 0)
-        return 1;
-    if (planIsEmpty(plan)) {
-        out(upToDate(SCHEMA_VERSION, collections.length));
-        return args.check ? checkKey(out, cwd, deps) : 0;
-    }
-    if (args.check)
-        return 1;
-    for (const f of [...plan.copy, ...(plan.views ? [plan.views] : [])])
-        await writeFile(join(appDir, f.name), f.text, "utf8");
-    out(NEXT_STEP);
-    return 0;
-}

package/dist/cli/rebuild.d.ts

@@ -1,23 +0,0 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
-import type { ResolvedConfig } from "../config.ts";
-import { type SpaceConnection } from "./space-io.ts";
-export type RebuildArgs = Record<string, never>;
-export type RebuildDeps = {
-    cwd?: string;
-    connection?: SpaceConnection;
-    /** The app's config; default: loaded from the folder (load-config.ts). */
-    config?: ResolvedConfig;
-    /** Test seam: the projection; default rebuildSpace. */
-    rebuild?: (db: SupabaseClient, config: ResolvedConfig) => Promise<{
-        pages: number;
-        entries: number;
-        model: string;
-    }>;
-};
-/** The line a rebuild ends with: import's counts, and the model the rows now carry. */
-export declare const rebuildMessage: (r: {
-    pages: number;
-    entries: number;
-    model: string;
-}) => string;
-export declare function runRebuild(_args: RebuildArgs, out: (line: string) => void, deps?: RebuildDeps): Promise<number>;

package/dist/cli/rebuild.js

@@ -1,22 +0,0 @@
-import { schemaBehind, schemaBehindMessage } from "../schema-version.js";
-import { loadConfig } from "./load-config.js";
-import { connectFromEnv, readSchemaVersion, rebuildSpace, rebuiltMessage, schemaRefusal } from "./space-io.js";
-/** The line a rebuild ends with: import's counts, and the model the rows now carry. */
-export const rebuildMessage = (r) => `${rebuiltMessage(r).replace(/\.$/, "")} (model ${r.model}).`;
-export async function runRebuild(_args, out, deps = {}) {
-    const cwd = deps.cwd ?? process.cwd();
-    const { db } = deps.connection ?? connectFromEnv(cwd);
-    const schema = await readSchemaVersion(db);
-    if ("missing" in schema) {
-        out(schemaRefusal(schema.missing, "Rebuild"));
-        return 1;
-    }
-    // A behind schema has no delivery tables (version 8) or reads columns it lacks: refused before any write.
-    if (schemaBehind(schema.version)) {
-        out(schemaBehindMessage(schema.version));
-        return 1;
-    }
-    const config = deps.config ?? (await loadConfig(cwd));
-    out(rebuildMessage(await (deps.rebuild ?? rebuildSpace)(db, config)));
-    return 0;
-}

package/dist/cli/space-io.d.ts

@@ -1,41 +0,0 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
-import type { ResolvedConfig } from "../config.ts";
-import type { ContentTable } from "../sql-space.ts";
-import { type Row } from "../space-transfer.ts";
-export type SpaceConnection = {
-    db: SupabaseClient;
-};
-export declare const MEDIA_BUCKET = "media";
-/** Rows per request. A host may cap below it, so a read stops at the first empty page, not the first short one. */
-export declare const PAGE_ROWS = 1000;
-/** `.env.local`, then `.env`, as Next reads them; a variable already set wins (spec §5). Returns the files it read. */
-export declare function loadAppEnv(cwd: string, env?: Record<string, string | undefined>): string[];
-/** The app's content client, from its env. Run outside the app, the missing keys are a missing
- *  folder, so the error names the folder it looked in. */
-export declare function connectFromEnv(cwd: string, env?: Record<string, string | undefined>): SpaceConnection;
-export { readSchemaVersion } from "../schema-read.ts";
-/** The key's space projected whole into the delivery tables (spec 2026-10-07 delivery model §2): the stores and
- *  the site built from the config as the app's glue builds them, then every page and entry. */
-export declare function rebuildSpace(db: SupabaseClient, config: ResolvedConfig): Promise<{
-    model: string;
-    pages: number;
-    entries: number;
-    stale: number;
-}>;
-/** The line a rebuild ends with. */
-export declare const rebuiltMessage: (counts: {
-    pages: number;
-    entries: number;
-}) => string;
-export declare function schemaRefusal(missing: "key" | "schema", command: "Export" | "Import" | "Rebuild"): string;
-/** Every row of one table in one space, paged in primary-key order. The space filter is explicit: a service-role key sees every space. */
-export declare function readSpaceRows(db: SupabaseClient, table: ContentTable, space: string, where?: Record<string, string>, columns?: string): Promise<Row[]>;
-type StorageErrorLike = {
-    message: string;
-    statusCode?: string | number;
-    status?: number;
-};
-export declare const isNotFound: (e: StorageErrorLike) => boolean;
-export declare const isAlreadyExists: (e: StorageErrorLike) => boolean;
-/** The installed package's version for the manifest: `../../package.json` from src/cli/ and dist/cli/ alike. */
-export declare function packageVersion(): string;

package/dist/cli/space-io.js

@@ -1,84 +0,0 @@
-// packages/smoodly/src/cli/space-io.ts
-// What export and import share (spec 2026-09-28 export/import §5, §8):
-// the app's env and client (the space is the database's answer, read
-// after the schema check so a missing schema is refused first), the schema-
-// version read that doubles as the secret-key check, paged reads of one
-// space's rows, and the two storage error tests.
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { parseEnv } from "node:util";
-import { createSupabaseStores, siteOptions } from "../bind.js";
-import { createSmoodlyClient } from "../client.js";
-import { projectAll } from "../project.js";
-import { createSmoodlySite } from "../site.js";
-import { resolveSmoodlyEnv } from "../env.js";
-import { ROW_KEY } from "../space-transfer.js";
-export const MEDIA_BUCKET = "media";
-/** Rows per request. A host may cap below it, so a read stops at the first empty page, not the first short one. */
-export const PAGE_ROWS = 1000;
-/** `.env.local`, then `.env`, as Next reads them; a variable already set wins (spec §5). Returns the files it read. */
-export function loadAppEnv(cwd, env = process.env) {
-    const read = [];
-    for (const name of [".env.local", ".env"]) {
-        const file = join(cwd, name);
-        if (!existsSync(file))
-            continue;
-        read.push(name);
-        for (const [key, value] of Object.entries(parseEnv(readFileSync(file, "utf8")))) {
-            if (env[key] === undefined)
-                env[key] = value;
-        }
-    }
-    return read;
-}
-/** The app's content client, from its env. Run outside the app, the missing keys are a missing
- *  folder, so the error names the folder it looked in. */
-export function connectFromEnv(cwd, env = process.env) {
-    const read = loadAppEnv(cwd, env);
-    if (read.length === 0 && (!env.SMOODLY_URL || !env.SMOODLY_SECRET_KEY)) {
-        throw new Error(`smoodly: no .env.local or .env in ${cwd} — run this in your app's folder.`);
-    }
-    return { db: createSmoodlyClient(resolveSmoodlyEnv(env)) };
-}
-export { readSchemaVersion } from "../schema-read.js";
-/** The key's space projected whole into the delivery tables (spec 2026-10-07 delivery model §2): the stores and
- *  the site built from the config as the app's glue builds them, then every page and entry. */
-export async function rebuildSpace(db, config) {
-    const { pages, entries, assets, published } = createSupabaseStores(db, config);
-    const { projector, stamp } = createSmoodlySite(siteOptions(config, () => ({ pages, entries, assets, published })));
-    const names = [...(config.registry.collections ?? []), ...(config.registry.globals ?? [])].map((c) => c.name);
-    // The document stamp every row now carries, recorded as the space's current one (DESIGN §3).
-    return { ...(await projectAll({ stores: { pages, entries }, projector, names })), model: stamp };
-}
-/** The line a rebuild ends with. */
-export const rebuiltMessage = (counts) => `Rebuilt the delivery tables: ${counts.pages} ${counts.pages === 1 ? "page" : "pages"}, ${counts.entries} ${counts.entries === 1 ? "entry" : "entries"}.`;
-export function schemaRefusal(missing, command) {
-    return missing === "key"
-        ? `${command} needs SMOODLY_SECRET_KEY — the service-role key, or the cloud's write key. The publishable key reads no content.`
-        : "This database has no Smoodly schema. Run `npx smoodly migrate`, then `supabase db push` (hosted) or `supabase migration up` (local).";
-}
-/** Every row of one table in one space, paged in primary-key order. The space filter is explicit: a service-role key sees every space. */
-export async function readSpaceRows(db, table, space, where = {}, columns = "*") {
-    const rows = [];
-    for (let from = 0;;) {
-        let q = db.from(table).select(columns).eq("space_id", space);
-        for (const [column, value] of Object.entries(where))
-            q = q.eq(column, value);
-        for (const column of ROW_KEY[table])
-            q = q.order(column);
-        const res = await q.range(from, from + PAGE_ROWS - 1);
-        if (res.error)
-            throw new Error(`smoodly: reading ${table}: ${res.error.message}`);
-        const page = (res.data ?? []);
-        if (page.length === 0)
-            return rows;
-        rows.push(...page);
-        from += page.length;
-    }
-}
-export const isNotFound = (e) => String(e.statusCode) === "404" || e.status === 404 || /not.?found/i.test(e.message);
-export const isAlreadyExists = (e) => String(e.statusCode) === "409" || e.status === 409 || /already exists/i.test(e.message);
-/** The installed package's version for the manifest: `../../package.json` from src/cli/ and dist/cli/ alike. */
-export function packageVersion() {
-    return JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
-}

package/dist/client.d.ts

@@ -1,11 +0,0 @@
-import { type SupabaseClient } from "@supabase/supabase-js";
-import type { SmoodlyEnv } from "./env.ts";
-type ContentEnv = Pick<SmoodlyEnv, "url" | "secretKey" | "publishableKey">;
-export declare function clientOptions(env: ContentEnv): {
-    url: string;
-    key: string;
-    headers: Record<string, string>;
-};
-/** The server-side client the stores are built on. */
-export declare function createSmoodlyClient(env: ContentEnv): SupabaseClient;
-export {};

package/dist/client.js

@@ -1,54 +0,0 @@
-// How the secret reaches PostgREST. A JWT (the self-host service role, or
-// a cloud space key) rides as the bearer PostgREST derives the role from,
-// with the publishable key satisfying the API gateway's apikey check. A
-// Supabase `sb_secret_…` key is itself an apikey. Key *format*, not mode.
-import { createClient } from "@supabase/supabase-js";
-export function clientOptions(env) {
-    if (env.secretKey.startsWith("sb_secret_")) {
-        return { url: env.url, key: env.secretKey, headers: {} };
-    }
-    // The gateway's apikey is the publishable key, or the secret itself when the site runs
-    // without one (spec 2026-09-30 tester findings §4): a self-host service role is a valid apikey.
-    return { url: env.url, key: env.publishableKey || env.secretKey, headers: { Authorization: `Bearer ${env.secretKey}` } };
-}
-/** Where a framework adapter hears each database call (spec 2026-10-07 delivery model): the Astro request
- *  scope installs it and counts, so a test can hold a live page to one lookup. A global, not an import:
- *  the client stays free of any adapter. */
-const READ_COUNTER = Symbol.for("smoodly:read-counter");
-/** fetch that names the variable behind two failures supabase-js reports bare: the network
- *  ("TypeError: fetch failed") and PostgREST refusing the key. */
-function namedFetch(url) {
-    return async (input, init) => {
-        globalThis[READ_COUNTER]?.();
-        let res;
-        try {
-            res = await fetch(input, init);
-        }
-        catch (e) {
-            if (e instanceof Error && e.name === "AbortError")
-                throw e;
-            throw new TypeError(`can't reach SMOODLY_URL (${url}): ${e instanceof Error ? e.message : String(e)}`);
-        }
-        if (res.status !== 401)
-            return res;
-        // PostgREST's key errors are PGRST300–303; their message varies by version ("JWT cryptographic
-        // operation failed", "No suitable key or wrong key type").
-        const body = (await res.clone().json().catch(() => null));
-        if (typeof body?.message !== "string")
-            return res;
-        if (!(typeof body.code === "string" && /^PGRST30\d$/.test(body.code)) && !/JWT/i.test(body.message))
-            return res;
-        const headers = new Headers(res.headers);
-        headers.delete("content-length");
-        const message = `SMOODLY_SECRET_KEY is not a valid key for SMOODLY_URL (${url}): ${body.message}`;
-        return new Response(JSON.stringify({ ...body, message }), { status: 401, statusText: res.statusText, headers });
-    };
-}
-/** The server-side client the stores are built on. */
-export function createSmoodlyClient(env) {
-    const options = clientOptions(env);
-    return createClient(options.url, options.key, {
-        global: { headers: options.headers, fetch: namedFetch(options.url) },
-        auth: { persistSession: false, autoRefreshToken: false },
-    });
-}

package/dist/current-space.d.ts

@@ -1,4 +0,0 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
-type RpcClient = Pick<SupabaseClient, "rpc">;
-export declare function readCurrentSpace(db: RpcClient): Promise<string>;
-export {};

package/dist/current-space.js

@@ -1,9 +0,0 @@
-export async function readCurrentSpace(db) {
-    const res = await db.rpc("smoodly_current_space");
-    if (res.error)
-        throw new Error(`smoodly: reading the space: ${res.error.message}`);
-    if (typeof res.data !== "string" || !res.data) {
-        throw new Error("smoodly: smoodly_current_space() returned no space — is the schema up to date?");
-    }
-    return res.data;
-}

package/dist/document-stamp.d.ts

@@ -1,7 +0,0 @@
-import type { SiteOptions } from "./site.ts";
-/** Bumped by hand when the assembler's output changes shape; the upgrading guide names each bump. */
-export declare const DOCUMENT_FORMAT = 1;
-/** The parts of the registry that reach a document: what `cacheKey` hashes, minus the presentation. */
-export declare function documentModel(options: SiteOptions): unknown;
-/** `<format>:<model hash>` — what a delivery row's `model` column holds. */
-export declare function documentStamp(options: SiteOptions): string;

package/dist/document-stamp.js

@@ -1,48 +0,0 @@
-// The stamp a delivery row carries (DESIGN §3, the document stamp, 2026-10-08): which document format and
-// which content model built it. Not the cache key: the package version is in that one, not here, because a
-// release that leaves documents alone must leave them alone.
-import { modelKey } from "./model-key.js";
-import { schemaOf } from "./registration.js";
-/** Bumped by hand when the assembler's output changes shape; the upgrading guide names each bump. */
-export const DOCUMENT_FORMAT = 1;
-/** Schema keys that reach the admin only: a change to one leaves every document as it was. */
-const PRESENTATION = new Set(["title", "description", "sample", "icon", "preview", "group", "admin"]);
-/** A field descriptor without the parts that reach the admin only (a hidden condition decides what the editor shows). */
-function fieldModel(field) {
-    if (!field || typeof field !== "object")
-        return field;
-    const { hidden: _hidden, ...rest } = field;
-    return Object.fromEntries(Object.entries(rest).map(([k, v]) => [k, k === "fields" ? fieldsModel(v) : k === "of" ? fieldModel(v) : v]));
-}
-function fieldsModel(fields) {
-    if (!fields || typeof fields !== "object")
-        return fields;
-    return Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, fieldModel(v)]));
-}
-/** A schema without its presentation. */
-function schemaModel(schema) {
-    if (!schema || typeof schema !== "object")
-        return schema;
-    return Object.fromEntries(Object.entries(schema)
-        .filter(([k]) => !PRESENTATION.has(k))
-        .map(([k, v]) => [k, k === "fields" || k === "settings" ? fieldsModel(v) : v]));
-}
-/** The parts of the registry that reach a document: what `cacheKey` hashes, minus the presentation. */
-export function documentModel(options) {
-    return {
-        collections: options.collections.map(schemaModel),
-        // A global whole, its presentation dropped: its settings' defaults reach a visual item's document.
-        globals: (options.globals ?? []).map(schemaModel),
-        sections: options.sections.map((x) => schemaModel(schemaOf(x))),
-        elements: (options.elements ?? []).map((x) => schemaModel(schemaOf(x))),
-        pages: options.pages.map((x) => schemaModel(schemaOf(x))),
-        locales: options.locales,
-        homePageSlug: options.homePageSlug,
-        styles: options.styles,
-        custom: options.custom,
-    };
-}
-/** `<format>:<model hash>` — what a delivery row's `model` column holds. */
-export function documentStamp(options) {
-    return `${DOCUMENT_FORMAT}:${modelKey(documentModel(options))}`;
-}

package/dist/image/loaders.d.ts

@@ -1,15 +0,0 @@
-import type { ResolvedImage } from "../media.ts";
-export type ImageUrlOptions = {
-    width?: number;
-    quality?: number;
-    format?: string;
-};
-export type ImageLoader = {
-    name: string;
-    /** True when the URL already applies crop and hotspot. */
-    handlesCrop: boolean;
-    url(image: ResolvedImage, opts: ImageUrlOptions): string;
-};
-export declare const nextLoader: ImageLoader;
-/** The escape hatch: a URL for a width, through the loader. */
-export declare function imageUrl(image: ResolvedImage, opts?: ImageUrlOptions, loader?: ImageLoader): string;

package/dist/image/loaders.js

@@ -1,5 +0,0 @@
-export const nextLoader = { name: "next", handlesCrop: false, url: (image) => image.url };
-/** The escape hatch: a URL for a width, through the loader. */
-export function imageUrl(image, opts = {}, loader = nextLoader) {
-    return loader.url(image, opts);
-}

package/dist/image/next-config.d.ts

@@ -1,18 +0,0 @@
-export type RemotePattern = {
-    protocol: "http" | "https";
-    hostname: string;
-    port?: string;
-    pathname: string;
-};
-export type SmoodlyImagesConfig = {
-    remotePatterns: RemotePattern[];
-    dangerouslyAllowLocalIP?: true;
-};
-/** `localhost`, loopback and the RFC 1918 ranges — the hosts a local
- * Supabase stack answers on. A public hostname that happens to resolve
- * privately (a Docker alias) is not detected; set the flag by hand then. */
-export declare function isPrivateHost(hostname: string): boolean;
-/** The Supabase host's public media path as a remote pattern. Defined here, not in remote-pattern.ts: this
- *  entry loads in plain Node and imports nothing; remote-pattern.ts re-exports it for the Astro side. */
-export declare function mediaRemotePattern(url: string): RemotePattern;
-export declare function smoodlyImages(url?: string | undefined): SmoodlyImagesConfig;

package/dist/image/next-config.js

@@ -1,32 +0,0 @@
-/** `localhost`, loopback and the RFC 1918 ranges — the hosts a local
- * Supabase stack answers on. A public hostname that happens to resolve
- * privately (a Docker alias) is not detected; set the flag by hand then. */
-export function isPrivateHost(hostname) {
-    const h = hostname.replace(/^\[|\]$/g, "");
-    if (h === "localhost" || h.endsWith(".localhost") || h === "::1")
-        return true;
-    const m = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(h);
-    if (!m)
-        return false;
-    const [a, b] = [Number(m[1]), Number(m[2])];
-    return a === 127 || a === 10 || (a === 192 && b === 168) || (a === 172 && b >= 16 && b <= 31);
-}
-/** The Supabase host's public media path as a remote pattern. Defined here, not in remote-pattern.ts: this
- *  entry loads in plain Node and imports nothing; remote-pattern.ts re-exports it for the Astro side. */
-export function mediaRemotePattern(url) {
-    const u = new URL(url);
-    return {
-        protocol: u.protocol === "http:" ? "http" : "https",
-        hostname: u.hostname,
-        ...(u.port ? { port: u.port } : {}),
-        pathname: "/storage/v1/object/public/media/**",
-    };
-}
-export function smoodlyImages(url = process.env.SMOODLY_URL) {
-    if (!url) {
-        console.warn("smoodly: SMOODLY_URL is not set — next/image will refuse Supabase media URLs until it is.");
-        return { remotePatterns: [] };
-    }
-    const pattern = mediaRemotePattern(url);
-    return { remotePatterns: [pattern], ...(isPrivateHost(new URL(url).hostname) ? { dangerouslyAllowLocalIP: true } : {}) };
-}

package/dist/image/remote-pattern.d.ts

@@ -1 +0,0 @@
-export { mediaRemotePattern, type RemotePattern } from "./next-config.ts";

package/dist/image/remote-pattern.js

@@ -1,5 +0,0 @@
-// The Supabase host's public media path as a remote pattern (spec 2026-09-08 media §9): what next/image
-// (next-config.ts) and Astro's image service (astro/index.ts) are both told they may resize from.
-// The function lives in next-config.ts, which must import nothing (it loads in plain Node from
-// next.config.ts); this module is the import path the Astro side uses.
-export { mediaRemotePattern } from "./next-config.js";

package/dist/migrations.d.ts

@@ -1,37 +0,0 @@
-export type MigrationFile = {
-    name: string;
-    text: string;
-};
-export type CollectionSQL = {
-    name: string;
-    sql: string;
-};
-export declare const MARKER_PREFIX = "-- smoodly:collection ";
-/** The first 16 hex chars of sha256 over the exact emitted SQL. */
-export declare const collectionHash: (sql: string) => string;
-export declare const collectionMarker: (c: CollectionSQL) => string;
-/** name → hash, the LAST marker per collection across the files in name order. */
-export declare function parseMarkers(files: MigrationFile[]): Map<string, string>;
-/** UTC yyyyMMddHHmmss — the Supabase CLI's file-name prefix. */
-export declare const stamp: (at: Date) => string;
-/** A views file must sort after every core file it may depend on and
- *  after any earlier views file it supersedes: the later of `now` and the
- *  newest own stamp plus a minute. */
-export declare function viewsStamp(names: string[], now: Date): Date;
-/** One file with a block per new or changed collection; null when none changed. */
-export declare function viewsFile(collections: CollectionSQL[], existing: Map<string, string>, at: Date): MigrationFile | null;
-export type CorePending = {
-    copy: MigrationFile[];
-    modified: string[];
-};
-/** Package files the app lacks (copy) and same-named files whose text differs (modified — never overwritten). */
-export declare function pendingCoreFiles(packageFiles: MigrationFile[], appFiles: MigrationFile[]): CorePending;
-export type MigratePlan = CorePending & {
-    views: MigrationFile | null;
-};
-export declare function planMigrate(input: {
-    packageFiles: MigrationFile[];
-    appFiles: MigrationFile[];
-    collections: CollectionSQL[];
-}, now: Date): MigratePlan;
-export declare const planIsEmpty: (plan: MigratePlan) => boolean;