smoodly 0.0.51 → 0.0.53

package/dist/astro/static-media.js

@@ -0,0 +1,55 @@
+export const STATIC_MEDIA_DIR = "/_smoodly/media";
+const hex = (bytes) => [...new Uint8Array(bytes)].map((b) => b.toString(16).padStart(2, "0")).join("");
+/** `/_smoodly/media/<sha256(sourceUrl + format), first 16 hex>.<ext>`: the same address and format, the same file. */
+export async function staticMediaPath(sourceUrl, format, ext) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${sourceUrl}\n${format}`));
+    return `${STATIC_MEDIA_DIR}/${hex(digest).slice(0, 16)}.${ext}`;
+}
+/** An original's extension from its address (`…/a1.jpg` → `jpg`), else `bin`. */
+const extOf = (url) => /\.([a-z0-9]{1,8})$/i.exec(new URL(url).pathname)?.[1]?.toLowerCase() ?? "bin";
+const candidates = (srcset) => srcset.split(", ").map((c) => { const [url, width] = c.trim().split(/\s+/); return { url: url, ...(width ? { width } : {}) }; });
+/** The markup with every media address replaced by a file of the output, each file handed to `register`. */
+export async function rewriteForStatic(m, register) {
+    const file = async (url, format) => {
+        const path = await staticMediaPath(url, format, format === "original" ? extOf(url) : format);
+        register({ url, format, path });
+        return path;
+    };
+    const inFormat = async (list, format) => (await Promise.all(list.map(async (c) => `${await file(c.url, format)}${c.width ? ` ${c.width}` : ""}`))).join(", ");
+    // A cut lists widths; an original is one address with no descriptor.
+    const cutOf = (srcset) => (srcset && candidates(srcset).every((c) => c.width) ? candidates(srcset) : null);
+    const sources = [];
+    const both = async (base, list) => {
+        sources.push({ ...base, type: "image/avif", srcset: await inFormat(list, "avif") });
+        sources.push({ ...base, type: "image/webp", srcset: await inFormat(list, "webp") });
+    };
+    for (const { srcset, type: _type, ...base } of m.sources) {
+        const list = cutOf(srcset);
+        if (list)
+            await both(base, list);
+        else
+            sources.push({ ...base, srcset: await inFormat(candidates(srcset), "original") });
+    }
+    const main = cutOf(m.img.srcset);
+    const { srcset: _srcset, sizes, ...img } = m.img;
+    if (main) {
+        await both({ ...(sizes ? { sizes } : {}), width: img.width, height: img.height }, main);
+        return { ...m, sources, img: { ...img, src: await file(m.img.src, "webp") } };
+    }
+    return { ...m, sources, img: { ...img, ...(sizes ? { sizes } : {}), src: await file(m.img.src, "original") } };
+}
+/** Where a prerendered page hands its files: installed by the integration for one static build. */
+const COLLECTOR = Symbol.for("smoodly.staticMedia");
+/** The build's collector (index.ts, astro:build:start): every file the pages register, once per path. */
+export function collectStaticMedia() {
+    const entries = new Map();
+    globalThis[COLLECTOR] = (entry) => void entries.set(entry.path, entry);
+    return entries;
+}
+/** What Image.astro calls in a prerendered page of static output: the rewrite, each file handed to the build. */
+export async function staticImage(m) {
+    const register = globalThis[COLLECTOR];
+    if (!register)
+        throw new Error("smoodly: a static page rendered outside the integration's `astro build` — no build collects its images.");
+    return rewriteForStatic(m, register);
+}

package/dist/astro/static.d.ts

@@ -1,15 +1,10 @@
 import type { ResolvedConfig } from "../config.ts";
-import type { PublishedStore } from "../published.ts";
-import type { PageStore } from "../store.ts";
+import type { DeliveryReads } from "../site.ts";
 import { type LocaleRouting } from "./locale-paths.ts";
 type Href = (path: string, locale: string) => string;
-/** Every published page and entry address of every locale, as Astro's getStaticPaths entries. Pages come from
- *  the delivery tree (a node with no path, hidden or under a code address, is not a page); entries from the paths
- *  index's live rows, kept to the entries with a published delivery row — the Supabase delivery store lists entries
- *  with their document only, no path (0.0.48 built no entry page for it), and the index is what visitors reach. */
+/** Every published page and entry address of every locale, as Astro's getStaticPaths entries, each once. */
 export declare function staticPaths(deps: {
-    published: PublishedStore;
-    pages: PageStore;
+    delivery: DeliveryReads;
     config: ResolvedConfig;
     href: Href;
 }): Promise<{
@@ -18,9 +13,9 @@ export declare function staticPaths(deps: {
     };
 }[]>;
 /** The redirect rows as Astro's `redirects` config: old address → the target's current address, 308 (spec
- *  2026-09-26 redirects §7 at the host). A target with no live path in the locale is left out: a 404 as on demand. */
+ *  2026-09-26 redirects §7 at the host). The service leaves out a target with no live path in the locale. */
 export declare function redirectEntries(deps: {
-    pages: PageStore;
+    delivery: DeliveryReads;
     config: ResolvedConfig;
     href: Href;
 }): Promise<Record<string, {

package/dist/astro/static.js

@@ -4,32 +4,19 @@ const param = (site) => {
     const trimmed = site.replace(/^\/+/, "").replace(/\/+$/, "");
     return trimmed === "" ? undefined : trimmed;
 };
-/** Every published page and entry address of every locale, as Astro's getStaticPaths entries. Pages come from
- *  the delivery tree (a node with no path, hidden or under a code address, is not a page); entries from the paths
- *  index's live rows, kept to the entries with a published delivery row — the Supabase delivery store lists entries
- *  with their document only, no path (0.0.48 built no entry page for it), and the index is what visitors reach. */
+/** Every published page and entry address of every locale, as Astro's getStaticPaths entries, each once. */
 export async function staticPaths(deps) {
     const seen = new Set();
     const out = [];
-    const add = (site) => {
-        const p = param(site);
-        if (seen.has(p))
-            return;
-        seen.add(p);
-        out.push({ params: { path: p } });
-    };
-    const collections = (deps.config.registry.collections ?? []).map((c) => c.name);
     for (const locale of deps.config.locales.supported) {
-        for (const row of await deps.published.tree(locale))
-            if (row.path !== null)
-                add(deps.href(row.path, locale));
-        const published = new Set();
-        for (const name of collections)
-            for (const row of await deps.published.entries(name, { locale }))
-                published.add(row.id);
-        for (const row of await deps.pages.listLive(locale))
-            if (row.kind === "entry" && published.has(row.id))
-                add(deps.href(row.path, locale));
+        const { pages, entries } = await deps.delivery.addresses(locale);
+        for (const path of [...pages, ...entries]) {
+            const p = param(deps.href(path, locale));
+            if (seen.has(p))
+                continue;
+            seen.add(p);
+            out.push({ params: { path: p } });
+        }
     }
     return out;
 }
@@ -37,16 +24,13 @@ export async function staticPaths(deps) {
  *  some hosts. A stored path with any of them would redirect more than itself, so it is a literal address or nothing. */
 const literalAddress = (path) => !/[[\]*:]/.test(path);
 /** The redirect rows as Astro's `redirects` config: old address → the target's current address, 308 (spec
- *  2026-09-26 redirects §7 at the host). A target with no live path in the locale is left out: a 404 as on demand. */
+ *  2026-09-26 redirects §7 at the host). The service leaves out a target with no live path in the locale. */
 export async function redirectEntries(deps) {
     const out = {};
     for (const locale of deps.config.locales.supported) {
-        for (const row of await deps.pages.listRedirects(locale)) {
-            if (!literalAddress(row.path))
-                continue;
-            const current = (await deps.pages.targetPaths({ kind: row.kind, id: row.id }))[locale];
-            if (current && literalAddress(current))
-                out[deps.href(row.path, locale)] = { status: 308, destination: deps.href(current, locale) };
+        for (const row of (await deps.delivery.addresses(locale)).redirects) {
+            if (literalAddress(row.from) && literalAddress(row.to))
+                out[deps.href(row.from, locale)] = { status: 308, destination: deps.href(row.to, locale) };
         }
     }
     return out;

package/dist/canvas-marker.d.ts

@@ -0,0 +1,14 @@
+export type CanvasFlags = {
+    editor: true;
+} | {
+    version: string;
+};
+/** `path` with the marker as its last segment, before any query or hash. */
+export declare function markCanvasPath(path: string, flags: CanvasFlags): string;
+export type CanvasMarker = {
+    segments: string[];
+    editor: boolean;
+    version?: string;
+};
+/** The marker taken off a catch-all's segments, which a host may hand over encoded or not. */
+export declare function readCanvasMarker(segments: string[]): CanvasMarker;

package/dist/canvas-marker.js

@@ -0,0 +1,36 @@
+// The canvas marker: where the editor's canvas and History's frame say what they want of a draft render when the
+// host strips the query. Vercel keeps only a prerendered route's own params in the query, draft mode included, so
+// on Next the flags ride the path's last segment: `~editor` (mount the editor bridge) or `~version~<id>` (render a
+// stored version). The admin writes it (admin/editor/canvas-address.ts), the Next renderer reads it inside draft
+// mode only; outside draft mode a marked address is an ordinary miss. A slug never starts with `~`.
+const EDITOR = "~editor";
+const VERSION = "~version~";
+/** `path` with the marker as its last segment, before any query or hash. */
+export function markCanvasPath(path, flags) {
+    const cut = path.search(/[?#]/);
+    const [pathname, rest] = cut === -1 ? [path, ""] : [path.slice(0, cut), path.slice(cut)];
+    const segment = "editor" in flags ? EDITOR : VERSION + encodeURIComponent(flags.version);
+    return `${pathname.replace(/\/+$/, "")}/${segment}${rest}`;
+}
+/** The marker taken off a catch-all's segments, which a host may hand over encoded or not. */
+export function readCanvasMarker(segments) {
+    const last = segments.length > 0 ? safeDecode(segments[segments.length - 1]) : "";
+    const rest = segments.slice(0, -1);
+    if (last === EDITOR)
+        return { segments: rest, editor: true };
+    if (last.startsWith(VERSION) && last.length > VERSION.length) {
+        const raw = segments[segments.length - 1];
+        // The id was encoded once when the marker was written; a host that decoded the segment already handed it over plain.
+        const id = raw.startsWith(VERSION) ? safeDecode(raw.slice(VERSION.length)) : last.slice(VERSION.length);
+        return { segments: rest, editor: false, version: id };
+    }
+    return { segments, editor: false };
+}
+function safeDecode(segment) {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        return segment;
+    }
+}

package/dist/cli/api.d.ts

@@ -0,0 +1,14 @@
+export type CliApi = {
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body: unknown): Promise<T>;
+    /** The bytes, or null when the API answers 404. */
+    getBytes(path: string): Promise<Uint8Array | null>;
+    postBytes<T>(path: string, bytes: Uint8Array, mime: string): Promise<T>;
+};
+/** The API refused: its status, its code and its message, as the content API words them. */
+export declare class CliApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export declare function connectApi(cwd: string, env?: Record<string, string | undefined>, doFetch?: typeof fetch): CliApi;

package/dist/cli/api.js

@@ -0,0 +1,48 @@
+// The CLI's door to Smoodly's API (plan 2026-10-14 the service holds the stores): the site's env — SMOODLY_API_URL,
+// SMOODLY_SPACE_ID, SMOODLY_SECRET_KEY, from the app's env files — and the content API's envelope `{ ok, data }`.
+import { apiEnv } from "../env.js";
+import { loadAppEnv } from "./app-env.js";
+/** The API refused: its status, its code and its message, as the content API words them. */
+export class CliApiError extends Error {
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "CliApiError";
+    }
+}
+export function connectApi(cwd, env = process.env, doFetch = fetch) {
+    const read = loadAppEnv(cwd, env);
+    if (read.length === 0 && !env.SMOODLY_API_URL && !env.SMOODLY_SECRET_KEY) {
+        throw new Error(`smoodly: no .env.local or .env in ${cwd} — run this in your app's folder.`);
+    }
+    const { apiUrl, spaceId, key } = apiEnv(env);
+    const base = `${apiUrl}/v1/spaces/${encodeURIComponent(spaceId)}`;
+    async function call(path, init = {}) {
+        try {
+            return await doFetch(`${base}${path}`, { ...init, headers: { ...init.headers, authorization: `Bearer ${key}` } });
+        }
+        catch (e) {
+            throw new Error(`smoodly: can't reach SMOODLY_API_URL (${apiUrl}): ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    async function data(res) {
+        const body = (await res.json().catch(() => null));
+        if (body?.ok === true)
+            return body.data;
+        throw new CliApiError(res.status, typeof body?.code === "string" ? body.code : "internal", typeof body?.message === "string" ? body.message : `smoodly: SMOODLY_API_URL (${apiUrl}) answered ${res.status} with no message.`);
+    }
+    return {
+        get: async (path) => data(await call(path)),
+        post: async (path, body) => data(await call(path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) })),
+        async getBytes(path) {
+            const res = await call(path);
+            if (res.status === 404)
+                return null;
+            if (!res.ok)
+                return data(res);
+            return new Uint8Array(await res.arrayBuffer());
+        },
+        postBytes: async (path, bytes, mime) => data(await call(path, { method: "POST", headers: { "content-type": mime }, body: bytes })),
+    };
+}

package/dist/cli/app-env.d.ts

@@ -0,0 +1,2 @@
+/** `.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[];

package/dist/cli/app-env.js

@@ -0,0 +1,20 @@
+// The app's env files as the CLI reads them (spec 2026-09-28 export/import §5): `.env.local`, then `.env`, as Next
+// reads them; a variable already set wins.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseEnv } from "node:util";
+/** `.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;
+}

package/dist/cli/export.d.ts

@@ -1,14 +1,28 @@
-import { type SpaceConnection } from "./space-io.ts";
+import { type ContentTable } from "../space-transfer.ts";
+import { type ExportMember, type Row } from "../space-transfer.ts";
+import { type CliApi } from "./api.ts";
 export type ExportArgs = {
     out: string | null;
 };
 export type ExportDeps = {
     cwd?: string;
-    connection?: SpaceConnection;
+    api?: CliApi;
     now?: () => Date;
+    /** Where SMOODLY_SPACE_ID is read, after connectApi loaded the app's env files into it; default process.env. */
+    env?: Record<string, string | undefined>;
+};
+/** What a transfer starts from (the service's GET /transfer). */
+export type TransferHead = {
+    schemaVersion: number;
+    members: ExportMember[];
 };
 export declare const defaultExportDir: (now: Date) => string;
 export declare const folderExists: (dir: string) => string;
 export declare const CHANGED_DURING_EXPORT = "Content changed during export \u2014 run it again.";
 export declare const missingFile: (path: string) => string;
+/** The transfer's head, or null after printing the API's refusal of a database without the schema. */
+export declare function transferHead(api: CliApi, out: (line: string) => void): Promise<TransferHead | null>;
+/** Every page of one table, as the service answers it: `keys` reads only the key columns. */
+export declare function readTable(api: CliApi, table: ContentTable, keys?: boolean): Promise<Row[]>;
+export declare const mediaUrl: (path: string) => string;
 export declare function runExport(args: ExportArgs, out: (line: string) => void, deps?: ExportDeps): Promise<number>;

package/dist/cli/export.js

@@ -1,21 +1,50 @@
 // packages/smoodly/src/cli/export.ts
-// `smoodly export` (spec 2026-09-28 export/import §8): the key's space —
-// every content row, history included, and the media files — into a
-// folder. Reads only; the folder appears whole or not at all (written as
-// <dir>.partial, renamed last). The message strings are what the guide
-// quotes.
-import { existsSync } from "node:fs";
+// `smoodly export` (spec 2026-09-28 export/import §8; over the API since plan
+// 2026-10-14 the service holds the stores): the key's space — every content
+// row, history included, and the media files — into a folder. The service
+// pipes the rows without their space; the consistency check runs here, over
+// the whole export. Reads only; the folder appears whole or not at all
+// (written as <dir>.partial, renamed last). The message strings are what the
+// guide quotes.
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { schemaBehind, schemaBehindMessage } from "../schema-version.js";
-import { CONTENT_TABLES } from "../sql-space.js";
-import { FORMAT, brokenReferences, countRows, describeExport, emptyTables, fromSpace, sortRows, } from "../space-transfer.js";
-import { MEDIA_BUCKET, connectFromEnv, isNotFound, packageVersion, readSchemaVersion, readSpaceRows, schemaRefusal, } from "./space-io.js";
-import { readCurrentSpace } from "../current-space.js";
+import { fileURLToPath } from "node:url";
+import { CONTENT_TABLES } from "../space-transfer.js";
+import { FORMAT, brokenReferences, countRows, describeExport, emptyTables, sortRows, } from "../space-transfer.js";
+import { CliApiError, connectApi } from "./api.js";
 export const defaultExportDir = (now) => `smoodly-export-${now.toISOString().slice(0, 10)}`;
 export const folderExists = (dir) => `Refusing: ${dir} already exists. Remove it, or pass --out <dir>.`;
 export const CHANGED_DURING_EXPORT = "Content changed during export — run it again.";
 export const missingFile = (path) => `Warning: ${path} is missing from the media bucket (already broken on the site); its asset row is exported without a file.`;
+/** The installed package's version for the manifest: `../../package.json` from src/cli/ and dist/cli/ alike. */
+function packageVersion() {
+    return JSON.parse(readFileSync(fileURLToPath(new URL("../../package.json", import.meta.url).href), "utf8")).version;
+}
+/** The transfer's head, or null after printing the API's refusal of a database without the schema. */
+export async function transferHead(api, out) {
+    try {
+        return await api.get("/transfer");
+    }
+    catch (e) {
+        if (e instanceof CliApiError && e.code === "validation") {
+            out(e.message);
+            return null;
+        }
+        throw e;
+    }
+}
+/** Every page of one table, as the service answers it: `keys` reads only the key columns. */
+export async function readTable(api, table, keys = false) {
+    const rows = [];
+    for (let offset = 0; offset !== null;) {
+        const page = await api.get(`/transfer/rows/${table}?offset=${offset}${keys ? "&keys=1" : ""}`);
+        rows.push(...page.rows);
+        offset = page.next;
+    }
+    return rows;
+}
+export const mediaUrl = (path) => `/transfer/media?path=${encodeURIComponent(path)}`;
 export async function runExport(args, out, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const now = (deps.now ?? (() => new Date()))();
@@ -27,22 +56,16 @@ export async function runExport(args, out, deps = {}) {
         out(folderExists(shown));
         return 1;
     }
-    const { db } = deps.connection ?? connectFromEnv(cwd);
-    const schema = await readSchemaVersion(db);
-    if ("missing" in schema) {
-        out(schemaRefusal(schema.missing, "Export"));
-        return 1;
-    }
-    const space = await readCurrentSpace(db);
-    if (schemaBehind(schema.version)) {
-        out(schemaBehindMessage(schema.version));
+    const env = deps.env ?? process.env;
+    const api = deps.api ?? connectApi(cwd, env);
+    // Read after connectApi: it loads the app's .env files. The space's public id; the service knows its database's.
+    const space = env.SMOODLY_SPACE_ID ?? "";
+    const head = await transferHead(api, out);
+    if (!head)
         return 1;
-    }
     const rows = emptyTables();
-    for (const table of CONTENT_TABLES) {
-        const read = await readSpaceRows(db, table, space, table === "assets" ? { status: "ready" } : {});
-        rows[table] = sortRows(table, read.map((row) => fromSpace(table, row, space)));
-    }
+    for (const table of CONTENT_TABLES)
+        rows[table] = sortRows(table, await readTable(api, table));
     const broken = brokenReferences(rows);
     if (broken.length > 0) {
         out(CHANGED_DURING_EXPORT);
@@ -50,9 +73,6 @@ export async function runExport(args, out, deps = {}) {
             out(`  ${line}`);
         return 1;
     }
-    const members = await db.from("members").select("email, role").eq("space_id", space).order("email");
-    if (members.error)
-        throw new Error(`smoodly: reading members: ${members.error.message}`);
     const partial = `${dir}.partial`;
     await rm(partial, { recursive: true, force: true });
     await mkdir(join(partial, "rows"), { recursive: true });
@@ -62,15 +82,12 @@ export async function runExport(args, out, deps = {}) {
     let bytes = 0;
     for (const asset of rows.assets) {
         const path = String(asset.path);
-        const got = await db.storage.from(MEDIA_BUCKET).download(`${space}/${path}`);
-        if (got.error) {
-            if (!isNotFound(got.error))
-                throw new Error(`smoodly: downloading ${path}: ${got.error.message}`);
+        const data = await api.getBytes(mediaUrl(path));
+        if (!data) {
             missing.push(path);
             out(missingFile(path));
             continue;
         }
-        const data = new Uint8Array(await got.data.arrayBuffer());
         const file = join(partial, "media", path);
         await mkdir(dirname(file), { recursive: true });
         await writeFile(file, data);
@@ -82,13 +99,13 @@ export async function runExport(args, out, deps = {}) {
     }
     const manifest = {
         format: FORMAT,
-        schemaVersion: schema.version,
+        schemaVersion: head.schemaVersion,
         smoodlyVersion: packageVersion(),
         exportedAt: now.toISOString(),
         sourceSpace: space,
         counts: countRows(rows),
         media: { files, bytes, missing },
-        members: (members.data ?? []),
+        members: head.members,
     };
     await writeFile(join(partial, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
     await rename(partial, dir);

package/dist/cli/import.d.ts

@@ -1,23 +1,19 @@
-import { type ContentTable } from "../sql-space.ts";
-import { type SpaceConnection } from "./space-io.ts";
-import type { ResolvedConfig } from "../config.ts";
+import { type ContentTable } from "../space-transfer.ts";
+import { type CliApi } from "./api.ts";
 export type ImportArgs = {
     dir: string;
 };
 export type ImportDeps = {
     cwd?: string;
-    connection?: SpaceConnection;
-    /** The app's config, which the closing rebuild assembles with; default: loaded from the folder (load-config.ts). */
-    config?: ResolvedConfig;
+    api?: CliApi;
     batchSize?: number;
     /** Test seam: runs before each batch; a throw stops the import there. */
     beforeBatch?: (table: ContentTable, index: number) => void;
+    /** Where SMOODLY_SPACE_ID is read, after connectApi loaded the app's env files into it; default process.env. */
+    env?: Record<string, string | undefined>;
 };
-export declare const BATCH_ROWS = 500;
-export declare const notAnExport: (dir: string) => string;
-export declare const formatMismatch: (format: unknown) => string;
 export declare const RUN_AGAIN = "Run the same command again to continue: rows and files that landed are skipped.";
-export declare const MEMBERS_HEADING = "Members in the source \u2014 invite them in Settings \u203A Members:";
-export declare const nothingNew: (space: string) => string;
+export declare const MEMBERS_HEADING = "Members in the source \u2014 add them to the space's members in the project at smoodly.io:";
+export declare const nothingNew: () => string;
 export declare const CACHE_NOTE = "Restart or redeploy the app: it may have cached pages from while the space was empty.";
 export declare function runImport(args: ImportArgs, out: (line: string) => void, deps?: ImportDeps): Promise<number>;