@zveltio/sdk 2.0.7 → 3.0.0-beta.1

package/dist/schema-codegen.d.ts

@@ -0,0 +1,60 @@
+/**
+ * SQL → TypeScript codegen for extension-owned tables (S4-01).
+ *
+ * The aim: extensions' `ctx.db` is currently typed `any`, so a column rename
+ * is a silent runtime failure. This module parses an extension's migration
+ * SQL files and emits a `.d.ts` describing every table the extension owns,
+ * keyed for Kysely. Result: `ctx.db.selectFrom('zv_forms')` autocompletes
+ * column names in editors and `tsc` catches typos.
+ *
+ * Scope intentionally narrow:
+ *   - Handles `CREATE TABLE [IF NOT EXISTS]` and `ALTER TABLE … ADD COLUMN`.
+ *   - Maps the common Postgres types we see in extension migrations to TS.
+ *   - Ignores constraint-only ALTER TABLE statements (PRIMARY KEY, FK).
+ *   - Ignores CREATE INDEX, CREATE TYPE, CREATE FUNCTION, etc.
+ *
+ * Anything more exotic falls back to `unknown` so downstream code still
+ * compiles. The migration author is free to widen this module's regex when
+ * a real case arises.
+ */
+export interface Column {
+    name: string;
+    /** TypeScript type (e.g. 'string', 'number | null', 'Record<string, unknown>'). */
+    tsType: string;
+    /** The raw Postgres type as parsed — useful for codegen comments. */
+    pgType: string;
+    nullable: boolean;
+}
+export interface Table {
+    name: string;
+    columns: Column[];
+}
+export interface ParsedSchema {
+    tables: Table[];
+}
+/**
+ * Parse a single CREATE TABLE body — the text between the outer parens —
+ * into a list of columns. Constraint-only clauses (PRIMARY KEY (…), FOREIGN
+ * KEY (…), CHECK (…), UNIQUE (…), CONSTRAINT …) are skipped.
+ */
+export declare function parseColumnList(body: string): Column[];
+/**
+ * Parse one or more migration SQL strings into a normalized schema. Tables
+ * are merged across files: `CREATE TABLE foo (...)` followed by
+ * `ALTER TABLE foo ADD COLUMN bar text` produces a single `foo` table with
+ * `bar` appended. Last write wins for column re-declarations.
+ */
+export declare function parseSchema(sqlChunks: string[]): ParsedSchema;
+export interface CodegenOptions {
+    /** Top-level interface name (default: `ExtensionSchema`). */
+    interfaceName?: string;
+    /** Optional banner line above the file body (e.g. provenance comment). */
+    banner?: string;
+}
+/**
+ * Emit a Kysely-friendly `.d.ts`-style module body for a parsed schema.
+ * The result is plain TypeScript; callers write it wherever (typically
+ * `<extension>/.zveltio/db.d.ts`).
+ */
+export declare function emitTypeScript(schema: ParsedSchema, opts?: CodegenOptions): string;
+//# sourceMappingURL=schema-codegen.d.ts.map

package/dist/schema-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-codegen.d.ts","sourceRoot":"","sources":["../src/schema-codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAsMD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CA+BtD;AA6BD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,YAAY,CA+C7D;AAID,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,GAAE,cAAmB,GAAG,MAAM,CA0BtF"}

package/dist/schema-codegen.js

@@ -0,0 +1,369 @@
+/**
+ * SQL → TypeScript codegen for extension-owned tables (S4-01).
+ *
+ * The aim: extensions' `ctx.db` is currently typed `any`, so a column rename
+ * is a silent runtime failure. This module parses an extension's migration
+ * SQL files and emits a `.d.ts` describing every table the extension owns,
+ * keyed for Kysely. Result: `ctx.db.selectFrom('zv_forms')` autocompletes
+ * column names in editors and `tsc` catches typos.
+ *
+ * Scope intentionally narrow:
+ *   - Handles `CREATE TABLE [IF NOT EXISTS]` and `ALTER TABLE … ADD COLUMN`.
+ *   - Maps the common Postgres types we see in extension migrations to TS.
+ *   - Ignores constraint-only ALTER TABLE statements (PRIMARY KEY, FK).
+ *   - Ignores CREATE INDEX, CREATE TYPE, CREATE FUNCTION, etc.
+ *
+ * Anything more exotic falls back to `unknown` so downstream code still
+ * compiles. The migration author is free to widen this module's regex when
+ * a real case arises.
+ */
+// ─── Postgres → TypeScript type map ────────────────────────────────────────
+const NUMERIC_TYPES = new Set([
+    'int',
+    'int2',
+    'int4',
+    'int8',
+    'integer',
+    'bigint',
+    'smallint',
+    'serial',
+    'bigserial',
+    'smallserial',
+    'numeric',
+    'decimal',
+    'real',
+    'double precision',
+    'float',
+    'float4',
+    'float8',
+]);
+const STRING_TYPES = new Set([
+    'text',
+    'varchar',
+    'char',
+    'character',
+    'character varying',
+    'name',
+    'uuid',
+    'citext',
+    'inet',
+    'cidr',
+    'macaddr',
+]);
+const BOOLEAN_TYPES = new Set(['boolean', 'bool']);
+const DATE_TYPES = new Set([
+    'date',
+    'time',
+    'timetz',
+    'timestamp',
+    'timestamptz',
+    'timestamp without time zone',
+    'timestamp with time zone',
+    'time without time zone',
+    'time with time zone',
+]);
+const JSON_TYPES = new Set(['json', 'jsonb']);
+const BYTES_TYPES = new Set(['bytea']);
+function mapPgTypeToTs(pgType) {
+    // Normalize: lower-case, strip array brackets (handled separately), trim modifiers
+    const lower = pgType.toLowerCase().trim();
+    const isArray = /\[\]\s*$/.test(lower);
+    const base = lower
+        .replace(/\[\]\s*$/, '')
+        .replace(/\(.*\)/, '')
+        .trim();
+    let tsBase;
+    if (NUMERIC_TYPES.has(base))
+        tsBase = 'number';
+    else if (BOOLEAN_TYPES.has(base))
+        tsBase = 'boolean';
+    else if (DATE_TYPES.has(base))
+        tsBase = 'Date';
+    else if (JSON_TYPES.has(base))
+        tsBase = 'Record<string, unknown>';
+    else if (BYTES_TYPES.has(base))
+        tsBase = 'Uint8Array';
+    else if (STRING_TYPES.has(base))
+        tsBase = 'string';
+    else
+        tsBase = 'unknown';
+    return isArray ? `${tsBase}[]` : tsBase;
+}
+// ─── SQL parsing ───────────────────────────────────────────────────────────
+/**
+ * Strip line comments (`-- …`) and block comments (`/* … * /`) so they don't
+ * confuse the table/column regexes. Dollar-quoted blocks are preserved
+ * verbatim (function bodies).
+ */
+function stripComments(sql) {
+    let out = '';
+    let i = 0;
+    const n = sql.length;
+    let inSingle = false;
+    let dollarTag = null;
+    while (i < n) {
+        const ch = sql[i];
+        const next = sql[i + 1];
+        if (dollarTag !== null) {
+            out += ch;
+            if (sql.startsWith(dollarTag, i)) {
+                out += sql.slice(i + 1, i + dollarTag.length);
+                i += dollarTag.length;
+                dollarTag = null;
+            }
+            else {
+                i++;
+            }
+            continue;
+        }
+        if (inSingle) {
+            out += ch;
+            if (ch === "'" && next === "'") {
+                out += next;
+                i += 2;
+            }
+            else if (ch === "'") {
+                inSingle = false;
+                i++;
+            }
+            else
+                i++;
+            continue;
+        }
+        if (ch === '-' && next === '-') {
+            // line comment until \n
+            while (i < n && sql[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            i += 2;
+            while (i < n && !(sql[i] === '*' && sql[i + 1] === '/'))
+                i++;
+            i += 2;
+            continue;
+        }
+        if (ch === '$') {
+            // detect dollar tag like $$ or $body$
+            const m = sql.substring(i).match(/^\$[a-zA-Z_]*\$/);
+            if (m) {
+                dollarTag = m[0];
+                out += dollarTag;
+                i += dollarTag.length;
+                continue;
+            }
+        }
+        if (ch === "'") {
+            inSingle = true;
+            out += ch;
+            i++;
+            continue;
+        }
+        out += ch;
+        i++;
+    }
+    return out;
+}
+/**
+ * Find the matching closing `)` for the `(` at `openIdx`. Returns the index
+ * of the closing paren, or -1 if unbalanced. Skips parens inside string
+ * literals and dollar-quoted blocks.
+ */
+function findMatchingParen(sql, openIdx) {
+    let depth = 0;
+    let i = openIdx;
+    const n = sql.length;
+    let inSingle = false;
+    let dollarTag = null;
+    while (i < n) {
+        const ch = sql[i];
+        if (dollarTag !== null) {
+            if (sql.startsWith(dollarTag, i)) {
+                dollarTag = null;
+                i += sql.substring(i).match(/^\$[a-zA-Z_]*\$/)[0].length;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (inSingle) {
+            if (ch === "'" && sql[i + 1] === "'")
+                i += 2;
+            else if (ch === "'") {
+                inSingle = false;
+                i++;
+            }
+            else
+                i++;
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            i++;
+            continue;
+        }
+        if (ch === '$') {
+            const m = sql.substring(i).match(/^\$[a-zA-Z_]*\$/);
+            if (m) {
+                dollarTag = m[0];
+                i += dollarTag.length;
+                continue;
+            }
+        }
+        if (ch === '(')
+            depth++;
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+        i++;
+    }
+    return -1;
+}
+/**
+ * Parse a single CREATE TABLE body — the text between the outer parens —
+ * into a list of columns. Constraint-only clauses (PRIMARY KEY (…), FOREIGN
+ * KEY (…), CHECK (…), UNIQUE (…), CONSTRAINT …) are skipped.
+ */
+export function parseColumnList(body) {
+    const columns = [];
+    // Split on top-level commas; tracking paren depth so types like `numeric(10,2)`
+    // don't confuse us.
+    const parts = [];
+    let depth = 0;
+    let buf = '';
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (ch === '(')
+            depth++;
+        else if (ch === ')')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            parts.push(buf);
+            buf = '';
+            continue;
+        }
+        buf += ch;
+    }
+    if (buf.trim())
+        parts.push(buf);
+    for (const rawPart of parts) {
+        const part = rawPart.trim();
+        if (!part)
+            continue;
+        // Skip table-level constraints
+        if (/^(constraint|primary\s+key|foreign\s+key|unique|check|exclude|like)\b/i.test(part))
+            continue;
+        const col = parseColumnDef(part);
+        if (col)
+            columns.push(col);
+    }
+    return columns;
+}
+function parseColumnDef(line) {
+    // Match: <identifier> <type>(...)? <rest>
+    // Identifier can be quoted ("col name") or unquoted (col_name).
+    const m = line.match(/^\s*(?:"([^"]+)"|([a-zA-Z_][a-zA-Z0-9_]*))\s+(.+)$/);
+    if (!m)
+        return null;
+    const name = m[1] ?? m[2];
+    if (!name || name === '')
+        return null;
+    // The type can have a length modifier in parens, possibly followed by [] for arrays.
+    // Examples: TEXT, VARCHAR(255), NUMERIC(10,2), TIMESTAMPTZ, INT[], GEOGRAPHY(POINT, 4326)
+    const rest = m[3];
+    const typeMatch = rest.match(/^((?:character\s+varying|character|double\s+precision|timestamp\s+(?:without|with)\s+time\s+zone|time\s+(?:without|with)\s+time\s+zone|[a-zA-Z_][a-zA-Z0-9_]*)(?:\s*\([^)]*\))?(?:\s*\[\s*\])?)\s*(.*)$/i);
+    if (!typeMatch)
+        return null;
+    const pgType = typeMatch[1].trim();
+    const tail = typeMatch[2] ?? '';
+    const upperTail = ' ' + tail.toUpperCase() + ' ';
+    // NOT NULL ⇒ non-nullable. PRIMARY KEY also implies NOT NULL.
+    const notNull = / NOT NULL /.test(upperTail) || / PRIMARY KEY /.test(upperTail);
+    const tsBase = mapPgTypeToTs(pgType);
+    const tsType = notNull ? tsBase : `${tsBase} | null`;
+    return { name, pgType, tsType, nullable: !notNull };
+}
+/**
+ * Parse one or more migration SQL strings into a normalized schema. Tables
+ * are merged across files: `CREATE TABLE foo (...)` followed by
+ * `ALTER TABLE foo ADD COLUMN bar text` produces a single `foo` table with
+ * `bar` appended. Last write wins for column re-declarations.
+ */
+export function parseSchema(sqlChunks) {
+    const tables = new Map();
+    const order = [];
+    const ensureTable = (name) => {
+        if (!tables.has(name)) {
+            tables.set(name, new Map());
+            order.push(name);
+        }
+        return tables.get(name);
+    };
+    const allSql = sqlChunks.map(stripComments).join('\n');
+    // CREATE TABLE [IF NOT EXISTS] <name> ( <body> )
+    const createRe = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:"([^"]+)"|([a-zA-Z_][a-zA-Z0-9_]*))\s*\(/gi;
+    let m;
+    while ((m = createRe.exec(allSql)) !== null) {
+        const tableName = m[1] ?? m[2];
+        const openIdx = createRe.lastIndex - 1; // position of '('
+        const closeIdx = findMatchingParen(allSql, openIdx);
+        if (closeIdx < 0)
+            continue; // unbalanced — skip
+        const body = allSql.substring(openIdx + 1, closeIdx);
+        const columns = parseColumnList(body);
+        const tableCols = ensureTable(tableName);
+        for (const c of columns)
+            tableCols.set(c.name, c);
+        createRe.lastIndex = closeIdx + 1;
+    }
+    // ALTER TABLE <name> ADD COLUMN [IF NOT EXISTS] <col> <type> <rest>
+    const alterRe = /ALTER\s+TABLE\s+(?:"([^"]+)"|([a-zA-Z_][a-zA-Z0-9_]*))\s+ADD\s+COLUMN\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:"([^"]+)"|([a-zA-Z_][a-zA-Z0-9_]*))\s+([^;]+?)(?=;|$)/gi;
+    while ((m = alterRe.exec(allSql)) !== null) {
+        const tableName = m[1] ?? m[2];
+        const colName = m[3] ?? m[4];
+        const tail = m[5];
+        const col = parseColumnDef(`${colName} ${tail}`);
+        if (col) {
+            const tableCols = ensureTable(tableName);
+            tableCols.set(col.name, col);
+        }
+    }
+    return {
+        tables: order.map((name) => ({ name, columns: [...tables.get(name).values()] })),
+    };
+}
+/**
+ * Emit a Kysely-friendly `.d.ts`-style module body for a parsed schema.
+ * The result is plain TypeScript; callers write it wherever (typically
+ * `<extension>/.zveltio/db.d.ts`).
+ */
+export function emitTypeScript(schema, opts = {}) {
+    const interfaceName = opts.interfaceName ?? 'ExtensionSchema';
+    const lines = [];
+    lines.push('// AUTO-GENERATED by zveltio CLI — do NOT edit by hand.');
+    lines.push('// Regenerate with: zveltio extension types');
+    if (opts.banner)
+        lines.push(`// ${opts.banner}`);
+    lines.push('');
+    lines.push('/* eslint-disable */');
+    lines.push('');
+    lines.push(`export interface ${interfaceName} {`);
+    if (schema.tables.length === 0) {
+        lines.push('  // No tables parsed from migrations.');
+    }
+    for (const t of schema.tables) {
+        lines.push(`  ${quoteIdentifierIfNeeded(t.name)}: {`);
+        for (const c of t.columns) {
+            lines.push(`    ${quoteIdentifierIfNeeded(c.name)}: ${c.tsType}; // ${c.pgType}`);
+        }
+        lines.push('  };');
+    }
+    lines.push('}');
+    lines.push('');
+    return lines.join('\n');
+}
+function quoteIdentifierIfNeeded(name) {
+    return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name) ? name : `'${name.replace(/'/g, "\\'")}'`;
+}

package/dist/schema-watcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-watcher.d.ts","sourceRoot":"","sources":["../src/schema-watcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,gBAAgB,EAAE,KAAK,IAAI,CAAC;IACrD,kCAAkC;IAClC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;CAChC;AA4GD;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,MAAM,IAAI,CAAC,CAyErB;AAED,iDAAiD;AACjD,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAKf"}
+{"version":3,"file":"schema-watcher.d.ts","sourceRoot":"","sources":["../src/schema-watcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,gBAAgB,EAAE,KAAK,IAAI,CAAC;IACrD,kCAAkC;IAClC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;CAChC;AA0GD;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,MAAM,IAAI,CAAC,CAyErB;AAED,iDAAiD;AACjD,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAKf"}

package/dist/schema-watcher.js

@@ -62,9 +62,7 @@ function generateTypesFile(collections) {
 `;
     const interfaces = collections.map(collectionToInterface).join('\n\n');
     const collectionNames = collections.map((c) => `'${c.name}'`).join(' | ');
-    const collectionMap = collections
-        .map((c) => `  ${c.name}: ${toPascalCase(c.name)};`)
-        .join('\n');
+    const collectionMap = collections.map((c) => `  ${c.name}: ${toPascalCase(c.name)};`).join('\n');
     const clientType = `
 export type CollectionName = ${collectionNames || 'never'};
 

package/dist/studio/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Studio SDK surface (S3-02 + S3-03 + early S4-07 prep).
+ *
+ * Pure helpers for Studio extension authors:
+ *   - `makeFormProxy` / `applyFormAlterHooks` — form-alter pipeline that
+ *     `<Form>` renderers in core Studio call before render. Hooks add
+ *     fields, hide fields, reorder, attach validators.
+ *   - `sortSlotContributions` — stable priority-asc sort used by
+ *     `<Slot name>` to order extension contributions.
+ *
+ * The reactive registries themselves (Svelte 5 `$state`) live in
+ * `packages/studio/src/lib/extension-api.svelte.ts`. They import this
+ * module so the algorithm is one source of truth, while the studio side
+ * owns the runtime state.
+ *
+ * Exported via `@zveltio/sdk/studio`. Extension Svelte bundles can
+ * import-and-call too — useful for advanced authors who want to apply
+ * alters against their own custom forms.
+ */
+import type { FormAlterAPI, FormAlterHook, FormSchema, SlotContribution, StudioRoute, StudioFieldType, AssetPreviewHandler } from '../extension/index.js';
+interface FormProxy extends FormAlterAPI {
+    /** Commit the mutated schema after all hooks ran. */
+    commit(): FormSchema;
+}
+export declare function makeFormProxy(initial: FormSchema): FormProxy;
+/**
+ * Run every registered hook against the schema and return the result.
+ * Exception-safe: a throwing hook is logged and skipped, the rest still run.
+ */
+export declare function applyFormAlterHooks(hooks: FormAlterHook[], schema: FormSchema, ctx?: Record<string, unknown>): FormSchema;
+/**
+ * Sort slot contributions deterministically: priority asc (lower first),
+ * then registration order (stable sort).
+ */
+export declare function sortSlotContributions<T extends {
+    priority?: number;
+}>(items: T[]): T[];
+/** Register a top-level Studio page contributed by this extension. */
+export declare function registerRoute(route: StudioRoute): void;
+/**
+ * Register a Svelte component into a named composition slot (S3-03).
+ *
+ * @example
+ *   import { registerSlot } from '@zveltio/sdk/studio';
+ *   import RevenueWidget from './widgets/RevenueWidget.svelte';
+ *
+ *   registerSlot('dashboard.widgets', {
+ *     component: RevenueWidget,
+ *     priority: 10,
+ *     visible: (ctx) => (ctx.user as any)?.roles?.includes('finance'),
+ *   });
+ */
+export declare function registerSlot(name: string, contribution: SlotContribution): void;
+/**
+ * Register a Drupal-style form-alter hook (S3-02).
+ *
+ * @example
+ *   import { registerFormAlter } from '@zveltio/sdk/studio';
+ *
+ *   registerFormAlter('core:user-edit', (form) => {
+ *     form.addField({ after: 'email', field: { name: 'phone', type: 'tel' } });
+ *     form.hideField('legacy_pin');
+ *   });
+ */
+export declare function registerFormAlter(formId: string, hook: FormAlterHook): void;
+/** Register a custom Studio field type contributed by this extension. */
+export declare function registerFieldType(ft: StudioFieldType): void;
+/**
+ * Register a custom preview handler for asset URLs / MIME types.
+ *
+ * @example
+ *   import { registerAssetPreview } from '@zveltio/sdk/studio';
+ *   import PdfPreview from './PdfPreview.svelte';
+ *
+ *   registerAssetPreview({
+ *     match: (a) => a.mimeType === 'application/pdf',
+ *     component: PdfPreview,
+ *   });
+ */
+export declare function registerAssetPreview(handler: AssetPreviewHandler): void;
+/** Engine base URL — pre-installed by Studio for cross-origin fetches. */
+export declare function getEngineUrl(): string;
+export type { StudioExtensionAPI, StudioRoute, StudioFieldType, AssetPreviewHandler, SlotContribution, FormAlterHook, FormAlterAPI, FormSchema, FormField, } from '../extension/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/studio/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/studio/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,UAAU,EAEV,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,mBAAmB,EACpB,MAAM,uBAAuB,CAAC;AAE/B,UAAU,SAAU,SAAQ,YAAY;IACtC,qDAAqD;IACrD,MAAM,IAAI,UAAU,CAAC;CACtB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,CAoE5D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,aAAa,EAAE,EACtB,MAAM,EAAE,UAAU,EAClB,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAChC,UAAU,CAWZ;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAGtF;AAoCD,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAEtD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAE/E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAE3E;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAE3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAEvE;AAED,0EAA0E;AAC1E,wBAAgB,YAAY,IAAI,MAAM,CAGrC;AAID,YAAY,EACV,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,UAAU,EACV,SAAS,GACV,MAAM,uBAAuB,CAAC"}