@isomorph.ai/app-sdk 1.2.1

package/dist/integration-execute-input-rules.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Per-operation input rules of integration-execute-request: derived from each
+ * operation's then-block (propertyNames.enum, required, per-field overrides).
+ * The governance execute route, the app SDK and the kit's local check validate
+ * with validateIntegrationExecuteInput below, so a request is refused with the
+ * same message wherever it is made.
+ */
+export type IntegrationExecuteInputFieldRule = {
+    kind: 'integer';
+    required: boolean;
+    minimum: number;
+    maximum: number;
+    default?: number;
+} | {
+    kind: 'string';
+    required: boolean;
+    minLength: number;
+    maxLength?: number;
+    pattern?: string;
+} | {
+    kind: 'string[]';
+    required: boolean;
+    minItems: number;
+    maxItems: number;
+    uniqueItems: boolean;
+    item: {
+        minLength: number;
+        maxLength?: number;
+        pattern?: string;
+    };
+};
+export type IntegrationExecuteOperationRule = {
+    idempotencyKey: boolean;
+    fields: Record<string, IntegrationExecuteInputFieldRule>;
+};
+export declare const IntegrationExecuteInputRules: {
+    readonly "slack.channel.history": {
+        readonly idempotencyKey: false;
+        readonly fields: {
+            readonly limit: {
+                readonly kind: "integer";
+                readonly required: false;
+                readonly minimum: 1;
+                readonly maximum: 15;
+                readonly default: 15;
+            };
+        };
+    };
+    readonly "slack.message.post": {
+        readonly idempotencyKey: true;
+        readonly fields: {
+            readonly text: {
+                readonly kind: "string";
+                readonly required: true;
+                readonly minLength: 1;
+                readonly maxLength: 4000;
+            };
+        };
+    };
+    readonly "gmail.thread.list": {
+        readonly idempotencyKey: false;
+        readonly fields: {
+            readonly limit: {
+                readonly kind: "integer";
+                readonly required: false;
+                readonly minimum: 1;
+                readonly maximum: 15;
+                readonly default: 15;
+            };
+        };
+    };
+    readonly "gmail.message.read": {
+        readonly idempotencyKey: false;
+        readonly fields: {
+            readonly messageId: {
+                readonly kind: "string";
+                readonly required: true;
+                readonly minLength: 0;
+                readonly pattern: "^[A-Za-z0-9_-]{1,64}$";
+            };
+        };
+    };
+    readonly "gmail.message.send": {
+        readonly idempotencyKey: true;
+        readonly fields: {
+            readonly to: {
+                readonly kind: "string[]";
+                readonly required: true;
+                readonly minItems: 1;
+                readonly maxItems: 50;
+                readonly uniqueItems: true;
+                readonly item: {
+                    readonly minLength: 3;
+                    readonly maxLength: 254;
+                    readonly pattern: "^[^\\s@<>,;\"]+@[^\\s@<>,;\"]+\\.[^\\s@<>,;\"]+$";
+                };
+            };
+            readonly cc: {
+                readonly kind: "string[]";
+                readonly required: false;
+                readonly minItems: 1;
+                readonly maxItems: 50;
+                readonly uniqueItems: true;
+                readonly item: {
+                    readonly minLength: 3;
+                    readonly maxLength: 254;
+                    readonly pattern: "^[^\\s@<>,;\"]+@[^\\s@<>,;\"]+\\.[^\\s@<>,;\"]+$";
+                };
+            };
+            readonly bcc: {
+                readonly kind: "string[]";
+                readonly required: false;
+                readonly minItems: 1;
+                readonly maxItems: 50;
+                readonly uniqueItems: true;
+                readonly item: {
+                    readonly minLength: 3;
+                    readonly maxLength: 254;
+                    readonly pattern: "^[^\\s@<>,;\"]+@[^\\s@<>,;\"]+\\.[^\\s@<>,;\"]+$";
+                };
+            };
+            readonly subject: {
+                readonly kind: "string";
+                readonly required: true;
+                readonly minLength: 1;
+                readonly maxLength: 256;
+            };
+            readonly text: {
+                readonly kind: "string";
+                readonly required: true;
+                readonly minLength: 1;
+                readonly maxLength: 4000;
+            };
+            readonly replyToMessageId: {
+                readonly kind: "string";
+                readonly required: false;
+                readonly minLength: 0;
+                readonly pattern: "^[A-Za-z0-9_-]{1,64}$";
+            };
+        };
+    };
+    readonly "warehouse.view.read": {
+        readonly idempotencyKey: false;
+        readonly fields: {
+            readonly columns: {
+                readonly kind: "string[]";
+                readonly required: true;
+                readonly minItems: 1;
+                readonly maxItems: 32;
+                readonly uniqueItems: false;
+                readonly item: {
+                    readonly minLength: 0;
+                    readonly pattern: "^(?:\\*|[A-Za-z_][A-Za-z0-9_]{0,62})$";
+                };
+            };
+            readonly limit: {
+                readonly kind: "integer";
+                readonly required: false;
+                readonly minimum: 1;
+                readonly maximum: 1000;
+                readonly default: 100;
+            };
+        };
+    };
+};
+export type IntegrationExecuteOperation = keyof typeof IntegrationExecuteInputRules;
+/** The upper bound of one integer input as a literal type: integrationExecuteInputMaximum('slack.channel.history', 'limit') is 15. */
+export declare function integrationExecuteInputMaximum<O extends IntegrationExecuteOperation, F extends keyof (typeof IntegrationExecuteInputRules)[O]['fields']>(operation: O, field: F): Extract<(typeof IntegrationExecuteInputRules)[O]['fields'][F], {
+    maximum: number;
+}>['maximum'];
+export type IntegrationExecuteInputProblem = {
+    field: string;
+    message: string;
+};
+export type IntegrationExecuteInputValidation = {
+    ok: true;
+    input: Record<string, unknown>;
+} | {
+    ok: false;
+    problem: IntegrationExecuteInputProblem;
+};
+/**
+ * Validates one operation's input against the contract and returns it with the
+ * contract's defaults applied. The message names the field and its allowed
+ * range; it is the sentence the platform answers with, so a caller may show it.
+ */
+export declare function validateIntegrationExecuteInput(operation: string, input: unknown): IntegrationExecuteInputValidation;

package/dist/integration-execute-input-rules.js

@@ -0,0 +1,114 @@
+/* eslint-disable */
+// Code generated by tools/gen/gen.mjs from schema/*.json. DO NOT EDIT.
+export const IntegrationExecuteInputRules = {
+    "slack.channel.history": {
+        idempotencyKey: false,
+        fields: {
+            limit: { kind: "integer", required: false, minimum: 1, maximum: 15, default: 15 },
+        },
+    },
+    "slack.message.post": {
+        idempotencyKey: true,
+        fields: {
+            text: { kind: "string", required: true, minLength: 1, maxLength: 4000 },
+        },
+    },
+    "gmail.thread.list": {
+        idempotencyKey: false,
+        fields: {
+            limit: { kind: "integer", required: false, minimum: 1, maximum: 15, default: 15 },
+        },
+    },
+    "gmail.message.read": {
+        idempotencyKey: false,
+        fields: {
+            messageId: { kind: "string", required: true, minLength: 0, pattern: "^[A-Za-z0-9_-]{1,64}$" },
+        },
+    },
+    "gmail.message.send": {
+        idempotencyKey: true,
+        fields: {
+            to: { kind: "string[]", required: true, minItems: 1, maxItems: 50, uniqueItems: true, item: { minLength: 3, maxLength: 254, pattern: "^[^\\s@<>,;\"]+@[^\\s@<>,;\"]+\\.[^\\s@<>,;\"]+$" } },
+            cc: { kind: "string[]", required: false, minItems: 1, maxItems: 50, uniqueItems: true, item: { minLength: 3, maxLength: 254, pattern: "^[^\\s@<>,;\"]+@[^\\s@<>,;\"]+\\.[^\\s@<>,;\"]+$" } },
+            bcc: { kind: "string[]", required: false, minItems: 1, maxItems: 50, uniqueItems: true, item: { minLength: 3, maxLength: 254, pattern: "^[^\\s@<>,;\"]+@[^\\s@<>,;\"]+\\.[^\\s@<>,;\"]+$" } },
+            subject: { kind: "string", required: true, minLength: 1, maxLength: 256 },
+            text: { kind: "string", required: true, minLength: 1, maxLength: 4000 },
+            replyToMessageId: { kind: "string", required: false, minLength: 0, pattern: "^[A-Za-z0-9_-]{1,64}$" },
+        },
+    },
+    "warehouse.view.read": {
+        idempotencyKey: false,
+        fields: {
+            columns: { kind: "string[]", required: true, minItems: 1, maxItems: 32, uniqueItems: false, item: { minLength: 0, pattern: "^(?:\\*|[A-Za-z_][A-Za-z0-9_]{0,62})$" } },
+            limit: { kind: "integer", required: false, minimum: 1, maximum: 1000, default: 100 },
+        },
+    },
+};
+/** The upper bound of one integer input as a literal type: integrationExecuteInputMaximum('slack.channel.history', 'limit') is 15. */
+export function integrationExecuteInputMaximum(operation, field) {
+    const rule = IntegrationExecuteInputRules[operation].fields[field];
+    if (!rule || rule.kind !== 'integer')
+        throw new Error(`${String(operation)}.input.${String(field)} has no integer bound`);
+    return rule.maximum;
+}
+const patterns = new Map();
+function matches(pattern, value) {
+    let compiled = patterns.get(pattern);
+    if (!compiled) {
+        compiled = new RegExp(pattern, 'u');
+        patterns.set(pattern, compiled);
+    }
+    return compiled.test(value);
+}
+/**
+ * Validates one operation's input against the contract and returns it with the
+ * contract's defaults applied. The message names the field and its allowed
+ * range; it is the sentence the platform answers with, so a caller may show it.
+ */
+export function validateIntegrationExecuteInput(operation, input) {
+    const rule = IntegrationExecuteInputRules[operation];
+    if (!rule)
+        return { ok: false, problem: { field: 'operation', message: `${operation} is not a declared integration operation` } };
+    const raw = input === undefined ? {} : input;
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return { ok: false, problem: { field: 'input', message: 'input must be an object' } };
+    const given = raw;
+    for (const name of Object.keys(given))
+        if (!Object.prototype.hasOwnProperty.call(rule.fields, name))
+            return { ok: false, problem: { field: name, message: `${name} is not an input of ${operation}` } };
+    const out = {};
+    for (const [name, field] of Object.entries(rule.fields)) {
+        const value = given[name];
+        if (value === undefined || value === null) {
+            if (field.required)
+                return { ok: false, problem: { field: name, message: `${name} is required for ${operation}` } };
+            if (field.kind === 'integer' && field.default !== undefined)
+                out[name] = field.default;
+            continue;
+        }
+        if (field.kind === 'integer') {
+            if (typeof value !== 'number' || !Number.isInteger(value) || value < field.minimum || value > field.maximum)
+                return { ok: false, problem: { field: name, message: `${name} must be an integer between ${field.minimum} and ${field.maximum}` } };
+        }
+        else if (field.kind === 'string') {
+            if (typeof value !== 'string' || value.length < field.minLength || (field.maxLength !== undefined && value.length > field.maxLength))
+                return { ok: false, problem: { field: name, message: field.maxLength !== undefined ? `${name} must be ${field.minLength} to ${field.maxLength} characters` : `${name} must be a string of at least ${field.minLength} characters` } };
+            if (field.pattern && !matches(field.pattern, value))
+                return { ok: false, problem: { field: name, message: `${name} must match ${field.pattern}` } };
+        }
+        else {
+            if (!Array.isArray(value) || value.length < field.minItems || value.length > field.maxItems)
+                return { ok: false, problem: { field: name, message: `${name} must list ${field.minItems} to ${field.maxItems} items` } };
+            const seen = new Set();
+            for (const [index, item] of value.entries()) {
+                if (typeof item !== 'string' || item.length < field.item.minLength || (field.item.maxLength !== undefined && item.length > field.item.maxLength) || (field.item.pattern !== undefined && !matches(field.item.pattern, item)))
+                    return { ok: false, problem: { field: name, message: `${name}[${index}] is not a valid ${name} entry` } };
+                if (field.uniqueItems && seen.has(item))
+                    return { ok: false, problem: { field: name, message: `${name} must not repeat an entry` } };
+                seen.add(item);
+            }
+        }
+        out[name] = value;
+    }
+    return { ok: true, input: out };
+}

package/dist/supabase-compat.d.ts

@@ -0,0 +1,323 @@
+/**
+ * supabase-js compatibility layer for the Isomorph App SDK.
+ *
+ * Converted Supabase apps swap `createClient` from '@supabase/supabase-js' for
+ * `createSupabaseCompatClient(createClient())` and keep call sites unchanged.
+ * Everything here maps onto the existing Isomorph client surfaces only; nothing
+ * new is invented on the wire.
+ *
+ * Contract differences this bridges (all found in converted-app reviews):
+ * - supabase call sites destructure `{ data, error }` and expect NEVER to see a
+ *   throw; the Isomorph SDK returns values and throws IsomorphError. Every async
+ *   method here catches and returns a PostgrestError-shaped `error` instead.
+ * - `functions.invoke(name, { body })` must UNWRAP the `body` option before it
+ *   reaches the action server (supabase-js does; a passthrough left payloads
+ *   wrapped in `{ body: ... }`).
+ * - storage is bucket-scoped in supabase and path-scoped in Isomorph; object
+ *   keys are mapped as `<bucket>/<path>` so distinct buckets stay distinct.
+ */
+import { type IsomorphResult, type IsomorphUser, type RealtimeSubscription } from './index.js';
+/** PostgrestError-shaped error returned (never thrown) by every compat call. */
+export interface SupabaseCompatError {
+    message: string;
+    /** Isomorph error category (AUTH_REQUIRED, FORBIDDEN, ...) when known. */
+    code?: string;
+    details?: unknown;
+}
+export type SupabaseCompatResponse<Result> = {
+    data: Result;
+    error: null;
+    count: number | null;
+} | {
+    data: null;
+    error: SupabaseCompatError;
+    count: null;
+};
+/**
+ * Decode a selected result without asserting a relation shape the SDK cannot
+ * infer from a select string. The decoder should check the extra fields and
+ * return the desired shape; a thrown validation error becomes a compat error.
+ * Existing query errors bypass the decoder, and successful counts are retained.
+ */
+export declare function decodeSupabaseCompatResponse<T, Result>(response: SupabaseCompatResponse<T>, decode: (data: T) => Result): SupabaseCompatResponse<Result>;
+/**
+ * The structural slice of the Isomorph QueryBuilder the compat layer relies on.
+ * The real QueryBuilder satisfies this; tests can hand in fakes.
+ */
+export interface CompatQuerySource<T, Result = T[]> {
+    select(columns?: string, options?: {
+        count?: 'exact';
+        head?: boolean;
+    }): CompatQuerySource<T, Result>;
+    insert(values: unknown): CompatQuerySource<T, Result>;
+    update(values: unknown): CompatQuerySource<T, Result>;
+    upsert(values: unknown, options?: {
+        onConflict?: string | string[];
+    }): CompatQuerySource<T, Result>;
+    delete(): CompatQuerySource<T, Result>;
+    eq(column: string, value: unknown): CompatQuerySource<T, Result>;
+    neq(column: string, value: unknown): CompatQuerySource<T, Result>;
+    gt(column: string, value: unknown): CompatQuerySource<T, Result>;
+    gte(column: string, value: unknown): CompatQuerySource<T, Result>;
+    lt(column: string, value: unknown): CompatQuerySource<T, Result>;
+    lte(column: string, value: unknown): CompatQuerySource<T, Result>;
+    is(column: string, value: unknown): CompatQuerySource<T, Result>;
+    not(column: string, operator: string, value: unknown): CompatQuerySource<T, Result>;
+    in(column: string, values: unknown[]): CompatQuerySource<T, Result>;
+    ilike(column: string, value: string): CompatQuerySource<T, Result>;
+    or(expression: string): CompatQuerySource<T, Result>;
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+    }): CompatQuerySource<T, Result>;
+    limit(value: number): CompatQuerySource<T, Result>;
+    range(from: number, to: number): CompatQuerySource<T, Result>;
+    single(): CompatQuerySource<T, T>;
+    maybeSingle(): CompatQuerySource<T, T | null>;
+    execute(): Promise<IsomorphResult<Result>>;
+}
+/**
+ * Thenable supabase-style builder. Awaiting it resolves
+ * `{ data, error, count }` and NEVER rejects: Isomorph throws are caught and
+ * converted to a PostgrestError-shaped `error` with `data: null`.
+ */
+type CompatQueryResult<Result, Head extends boolean> = Head extends true ? null : Result;
+export declare class SupabaseCompatQueryBuilder<T, Result = T[], Head extends boolean = false> implements PromiseLike<SupabaseCompatResponse<CompatQueryResult<Result, Head>>> {
+    private readonly inner;
+    private readonly head;
+    constructor(inner: CompatQuerySource<T, Result>, ...head: [head: Head] | ([Head] extends [false] ? [] : never));
+    private chain;
+    select(columns: string | undefined, options: {
+        count?: 'exact';
+        head: true;
+    }): SupabaseCompatQueryBuilder<T, Result, true>;
+    select(columns?: string, options?: {
+        count?: 'exact';
+        head?: false;
+    }): SupabaseCompatQueryBuilder<T, Result, false>;
+    select(columns?: string, options?: {
+        count?: 'exact';
+        head?: boolean;
+    }): SupabaseCompatQueryBuilder<T, Result, boolean>;
+    insert(values: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    update(values: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    /** Optionless `upsert(row)` must pass through untouched (supabase allows it). */
+    upsert(values: unknown, options?: {
+        onConflict?: string | string[];
+    }): SupabaseCompatQueryBuilder<T, Result, Head>;
+    delete(): SupabaseCompatQueryBuilder<T, Result, Head>;
+    eq(column: string, value: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    neq(column: string, value: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    gt(column: string, value: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    gte(column: string, value: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    lt(column: string, value: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    lte(column: string, value: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    is(column: string, value: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    not(column: string, operator: string, value: unknown): SupabaseCompatQueryBuilder<T, Result, Head>;
+    in(column: string, values: unknown[]): SupabaseCompatQueryBuilder<T, Result, Head>;
+    ilike(column: string, value: string): SupabaseCompatQueryBuilder<T, Result, Head>;
+    or(expression: string): SupabaseCompatQueryBuilder<T, Result, Head>;
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+    }): SupabaseCompatQueryBuilder<T, Result, Head>;
+    limit(value: number): SupabaseCompatQueryBuilder<T, Result, Head>;
+    range(from: number, to: number): SupabaseCompatQueryBuilder<T, Result, Head>;
+    single(): SupabaseCompatQueryBuilder<T, T, Head>;
+    maybeSingle(): SupabaseCompatQueryBuilder<T, T | null, Head>;
+    private resolve;
+    then<TResult1 = SupabaseCompatResponse<CompatQueryResult<Result, Head>>, TResult2 = never>(onfulfilled?: ((value: SupabaseCompatResponse<CompatQueryResult<Result, Head>>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+}
+export interface SupabaseCompatUser {
+    id: string;
+    email: string;
+    app_metadata: Record<string, unknown>;
+    /** Isomorph's per-app user record (`IsomorphUser.appUser`) when it is an object. */
+    user_metadata: Record<string, unknown>;
+}
+export interface SupabaseCompatSession {
+    user: SupabaseCompatUser;
+    /**
+     * Isomorph authenticates with a gateway cookie; no bearer token exists. This
+     * placeholder keeps `if (session?.access_token)` truthiness checks working.
+     * It must never be forwarded as a credential.
+     */
+    access_token: string;
+    token_type: 'bearer';
+}
+export type SupabaseCompatAuthEvent = 'SIGNED_IN' | 'SIGNED_OUT';
+type CompatRealtimeStatus = 'SUBSCRIBED' | 'CLOSED' | 'CHANNEL_ERROR' | 'RECONNECTING' | 'REFETCH_REQUIRED';
+/** Structural slice of Isomorph's RealtimeChannelBuilder (already supabase-shaped). */
+export interface CompatChannel {
+    on(event: 'postgres_changes' | 'presence' | 'broadcast', filter: unknown, handler: (payload: unknown) => void): CompatChannel;
+    subscribe(callback?: (status: CompatRealtimeStatus) => void): RealtimeSubscription;
+}
+/**
+ * The slice of the Isomorph client the compat layer consumes. The object
+ * returned by the SDK's `createClient` satisfies it; tests can hand in fakes.
+ */
+export interface IsomorphCompatSource {
+    identity: {
+        current(): Promise<IsomorphUser | null>;
+        signOut(returnTo?: string): string;
+        onChange(listener: (user: IsomorphUser | null) => void): () => void;
+    };
+    data: {
+        from<T = Record<string, unknown>>(table: string): CompatQuerySource<T>;
+        rpc<T = unknown>(name: string, args?: Record<string, unknown>): Promise<T>;
+    };
+    files: {
+        upload(path: string, body: Blob, checksum?: string): Promise<unknown>;
+        list(prefix?: string): Promise<unknown[]>;
+        remove(paths: string[]): Promise<void>;
+        getPublicUrl(path: string): string;
+        createSignedUrl(path: string, expiresIn?: number): Promise<{
+            signedUrl: string;
+        }>;
+        createSignedUrls(paths: string[], expiresIn?: number): Promise<Array<{
+            path: string;
+            signedUrl: string;
+        }>>;
+    };
+    realtime: {
+        channel(name: string): CompatChannel;
+    };
+    actions: {
+        invoke<T = unknown>(name: string, input: unknown): Promise<T>;
+    };
+}
+export interface SupabaseCompatFunctionsInvokeOptions {
+    /** Unwrapped and sent as the action input, exactly as supabase-js does. */
+    body?: unknown;
+    /** Nonempty custom headers return an error; the Isomorph gateway owns headers. */
+    headers?: Record<string, string>;
+    /** Non-POST methods return an error; Isomorph actions are always POST. */
+    method?: 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';
+}
+/**
+ * Row typing from a supabase-js generated `Database` type. Pass it exactly as
+ * the source passed it to `createClient<Database>`:
+ * `createSupabaseCompatClient<Database>(isomorph)`. Without it every row is
+ * `Record<string, unknown>`, and an application that relied on the generated
+ * types loses them at every access (ERP: `Type 'unknown' is not assignable`
+ * across its components after conversion).
+ */
+type CompatTables<Database> = Database extends {
+    public: {
+        Tables: infer T;
+    };
+} ? T : never;
+export type CompatRow<Database, Name extends string> = [CompatTables<Database>] extends [never] ? Record<string, unknown> : Name extends keyof CompatTables<Database> ? CompatTables<Database>[Name] extends {
+    Row: infer R;
+} ? R : Record<string, unknown> : Record<string, unknown>;
+/**
+ * Build a supabase-js-shaped client on top of an existing Isomorph client.
+ * Pass the object returned by the SDK's `createClient`.
+ */
+export declare function createSupabaseCompatClient<Database = never>(isomorph: IsomorphCompatSource): {
+    from<Name extends string>(table: Name): SupabaseCompatQueryBuilder<CompatRow<Database, Name>, CompatRow<Database, Name>[]>;
+    rpc: <T = unknown>(name: string, params?: Record<string, unknown>) => Promise<{
+        data: T | null;
+        error: SupabaseCompatError | null;
+    }>;
+    auth: {
+        getSession: () => Promise<{
+            data: {
+                session: SupabaseCompatSession | null;
+            };
+            error: SupabaseCompatError | null;
+        }>;
+        getUser: () => Promise<{
+            data: {
+                user: SupabaseCompatUser | null;
+            };
+            error: SupabaseCompatError | null;
+        }>;
+        onAuthStateChange: (callback: (event: SupabaseCompatAuthEvent, session: SupabaseCompatSession | null) => void) => {
+            data: {
+                subscription: {
+                    unsubscribe: () => void;
+                };
+            };
+        };
+        /**
+         * The Isomorph edge gateway owns sign-out: this clears local identity and
+         * redirects the browser through /__harbour/logout (via identity.signOut).
+         */
+        signOut: () => Promise<{
+            error: null;
+        }>;
+    };
+    functions: {
+        invoke: <T = unknown>(name: string, options?: SupabaseCompatFunctionsInvokeOptions) => Promise<{
+            data: T | null;
+            error: SupabaseCompatError | null;
+        }>;
+    };
+    storage: {
+        from: (bucket: string) => {
+            upload: (path: string, body: Blob | ArrayBuffer | ArrayBufferView<ArrayBuffer> | string, options?: {
+                contentType?: string;
+                upsert?: boolean;
+                cacheControl?: string;
+            }) => Promise<{
+                data: {
+                    path: string;
+                    fullPath: string;
+                } | null;
+                error: SupabaseCompatError | null;
+            }>;
+            /** Mapped through createSignedUrl + a plain fetch of the signed URL. */
+            download: (path: string) => Promise<{
+                data: Blob | null;
+                error: SupabaseCompatError | null;
+            }>;
+            remove: (paths: string[]) => Promise<{
+                data: Array<{
+                    name: string;
+                }> | null;
+                error: SupabaseCompatError | null;
+            }>;
+            list: (prefix?: string) => Promise<{
+                data: unknown[] | null;
+                error: SupabaseCompatError | null;
+            }>;
+            /** Sync, like supabase-js: URL construction only, no network call. */
+            getPublicUrl: (path: string) => {
+                data: {
+                    publicUrl: string;
+                };
+            };
+            createSignedUrl: (path: string, expiresIn?: number) => Promise<{
+                data: {
+                    signedUrl: string;
+                } | null;
+                error: SupabaseCompatError | null;
+            }>;
+            createSignedUrls: (paths: string[], expiresIn?: number) => Promise<{
+                data: Array<{
+                    path: string;
+                    signedUrl: string;
+                }> | null;
+                error: SupabaseCompatError | null;
+            }>;
+            /** No Isomorph files move; declared so call sites fail loudly, not with a TypeError. */
+            move: (fromPath: string, toPath: string) => Promise<{
+                data: null;
+                error: SupabaseCompatError;
+            }>;
+            /** No Isomorph files copy; declared so call sites fail loudly, not with a TypeError. */
+            copy: (fromPath: string, toPath: string) => Promise<{
+                data: null;
+                error: SupabaseCompatError;
+            }>;
+        };
+    };
+    /** Isomorph's channel builder is already supabase-shaped; pure passthrough. */
+    channel: (name: string) => CompatChannel;
+    removeChannel: (subscription: RealtimeSubscription) => Promise<"ok" | "error">;
+};
+export type SupabaseCompatClient = ReturnType<typeof createSupabaseCompatClient>;
+type Extends<A extends B, B> = A;
+type IsomorphClientSatisfiesCompatSource = Extends<import('./index.js').IsomorphClient, IsomorphCompatSource>;
+export type { IsomorphClientSatisfiesCompatSource as _IsomorphClientSatisfiesCompatSource };