@voobase/cli 0.1.1-nonprod.2039 → 0.1.1-nonprod.2050

package/runtime-sdk/dist/data-form/client.js

@@ -0,0 +1,118 @@
+import { buildDataFormRuntimeRecordPath, buildDataFormRuntimeRecordsPath, buildDataFormRuntimeResourcesPath, buildDataFormRuntimeSchemaPath, normalizeDataFormRuntimeListQuery, } from "./contracts.js";
+import { BaseRuntimeSdk } from "../http.js";
+const DEFAULT_PREVIEW_PATH_PREFIX = "/previews";
+const PREVIEW_ROUTE_KIND_SEGMENTS = new Set(["r", "s"]);
+function inferPreviewPath(pathname) {
+    const normalizedPathname = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    if (normalizedPathname !== DEFAULT_PREVIEW_PATH_PREFIX && !normalizedPathname.startsWith(`${DEFAULT_PREVIEW_PATH_PREFIX}/`)) {
+        return false;
+    }
+    const segments = normalizedPathname
+        .slice(DEFAULT_PREVIEW_PATH_PREFIX.length)
+        .replace(/^\/+/g, "")
+        .split("/")
+        .filter((segment) => segment.length > 0);
+    if (segments.length < 2) {
+        return false;
+    }
+    if (PREVIEW_ROUTE_KIND_SEGMENTS.has(segments[0] ?? "")) {
+        return segments.length >= 4;
+    }
+    return true;
+}
+export class RuntimeDataFormClient extends BaseRuntimeSdk {
+    constructor(options) {
+        super(options);
+    }
+    resolveRuntimeEnv() {
+        if (this.options.env === "preview" || this.options.env === "prod") {
+            return this.options.env;
+        }
+        const runtimeConfigEnv = readBrowserRuntimeEnv();
+        if (runtimeConfigEnv) {
+            return runtimeConfigEnv;
+        }
+        const baseUrl = resolveRouteBaseUrl(this.options);
+        try {
+            const pathname = new URL(baseUrl).pathname;
+            return inferPreviewPath(pathname) ? "preview" : "prod";
+        }
+        catch {
+            return "prod";
+        }
+    }
+    withRuntimeEnv(path) {
+        const url = new URL(path, "http://platform.local/");
+        url.searchParams.set("env", this.resolveRuntimeEnv());
+        return `${url.pathname}${url.search}`;
+    }
+    async listResources() {
+        return this.request(this.withRuntimeEnv(buildDataFormRuntimeResourcesPath(this.options.appId)));
+    }
+    async getSchema(resourceKey) {
+        return this.request(this.withRuntimeEnv(buildDataFormRuntimeSchemaPath(this.options.appId, resourceKey)));
+    }
+    async listRecords(args) {
+        const query = normalizeDataFormRuntimeListQuery({
+            page: args.page,
+            page_size: args.pageSize,
+            owner_scope: args.ownerScope,
+            q: args.q
+        });
+        const path = new URL(buildDataFormRuntimeRecordsPath(this.options.appId, args.resourceKey), "http://platform.local/");
+        path.searchParams.set("page", String(query.page));
+        path.searchParams.set("page_size", String(query.page_size));
+        path.searchParams.set("owner_scope", query.owner_scope);
+        if (query.q) {
+            path.searchParams.set("q", query.q);
+        }
+        path.searchParams.set("env", this.resolveRuntimeEnv());
+        return this.request(`${path.pathname}${path.search}`);
+    }
+    async getRecord(resourceKey, recordId) {
+        return this.request(this.withRuntimeEnv(buildDataFormRuntimeRecordPath(this.options.appId, resourceKey, recordId)));
+    }
+    async createRecord(resourceKey, input) {
+        return this.request(this.withRuntimeEnv(buildDataFormRuntimeRecordsPath(this.options.appId, resourceKey)), {
+            method: "POST",
+            body: JSON.stringify(input)
+        });
+    }
+    async updateRecord(resourceKey, recordId, input) {
+        return this.request(this.withRuntimeEnv(buildDataFormRuntimeRecordPath(this.options.appId, resourceKey, recordId)), {
+            method: "PATCH",
+            body: JSON.stringify(input)
+        });
+    }
+}
+function resolveRouteBaseUrl(options) {
+    const explicitPublicBaseUrl = options.publicBaseUrl?.trim();
+    if (explicitPublicBaseUrl) {
+        return explicitPublicBaseUrl;
+    }
+    const browserPublicBaseUrl = readBrowserRuntimeConfig()?.publicBaseUrl;
+    if (typeof browserPublicBaseUrl === "string" && browserPublicBaseUrl.trim()) {
+        return browserPublicBaseUrl.trim();
+    }
+    return options.baseUrl.trim();
+}
+function readBrowserRuntimeEnv() {
+    const runtimeConfig = readBrowserRuntimeConfig();
+    if (!runtimeConfig) {
+        return undefined;
+    }
+    if (runtimeConfig.env === "preview" || runtimeConfig.env === "prod") {
+        return runtimeConfig.env;
+    }
+    if (runtimeConfig.mode === "preview") {
+        return "preview";
+    }
+    if (runtimeConfig.mode === "prod-path" || runtimeConfig.mode === "prod-host") {
+        return "prod";
+    }
+    return undefined;
+}
+function readBrowserRuntimeConfig() {
+    const runtimeWindow = globalThis.window;
+    return runtimeWindow?.__PLATFORM_RUNTIME_CONFIG__;
+}

package/runtime-sdk/dist/data-form/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/runtime-sdk/dist/data-form/client.test.js

@@ -0,0 +1,210 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import { RuntimeDataFormClient } from "./client.js";
+test("runtime data form client keeps mounted preview path single when building requests", async () => {
+    const calls = [];
+    const client = new RuntimeDataFormClient({
+        baseUrl: "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/",
+        appId: "app-demo",
+        fetchImpl: async (input, init) => {
+            const url = String(input);
+            calls.push({ url, method: String(init?.method ?? "GET") });
+            if (url === "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/data-form/resources?env=preview") {
+                return jsonResponse({ resources: [] });
+            }
+            if (url === "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/data-form/resources/profile/schema?env=preview") {
+                return jsonResponse({
+                    resource: {
+                        resource_key: "profile",
+                        display_name: "Profile",
+                        resource_kind: "end_user_owned",
+                        owner_type: "identity",
+                        sharing_mode: "app_scoped",
+                        access_policy: {
+                            create: "own",
+                            read: "own",
+                            update: "own"
+                        },
+                        fields: []
+                    }
+                });
+            }
+            if (url ===
+                "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/data-form/resources/profile/records?page=2&page_size=5&owner_scope=all&q=demo&env=preview") {
+                return jsonResponse({
+                    items: [],
+                    page: 2,
+                    page_size: 5,
+                    total: 0,
+                    has_more: false
+                });
+            }
+            if (url === "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/data-form/resources/profile/records?env=preview") {
+                return jsonResponse({
+                    record_id: "rec_1",
+                    resource_key: "profile",
+                    owner_identity_id: "id_1",
+                    values: { nickname: "neo" },
+                    created_at: "2026-05-15T00:00:00.000Z",
+                    updated_at: "2026-05-15T00:00:00.000Z"
+                }, 201);
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const resources = await client.listResources();
+    const schema = await client.getSchema("profile");
+    const list = await client.listRecords({ resourceKey: "profile", page: 2, pageSize: 5, ownerScope: "all", q: " demo " });
+    const created = await client.createRecord("profile", {
+        values: {
+            nickname: "neo"
+        }
+    });
+    assert.deepEqual(resources, { resources: [] });
+    assert.equal(schema.resource.resource_key, "profile");
+    assert.equal(list.page, 2);
+    assert.equal(created.record_id, "rec_1");
+    assert.deepEqual(calls, [
+        {
+            url: "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/data-form/resources?env=preview",
+            method: "GET"
+        },
+        {
+            url: "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/data-form/resources/profile/schema?env=preview",
+            method: "GET"
+        },
+        {
+            url: "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/data-form/resources/profile/records?page=2&page_size=5&owner_scope=all&q=demo&env=preview",
+            method: "GET"
+        },
+        {
+            url: "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/data-form/resources/profile/records?env=preview",
+            method: "POST"
+        }
+    ]);
+});
+function jsonResponse(payload, status = 200) {
+    return new Response(JSON.stringify(payload), {
+        status,
+        headers: { "Content-Type": "application/json" }
+    });
+}
+test("runtime data form client prefers explicit env instead of inferring prod from localhost base url", async () => {
+    const calls = [];
+    const client = new RuntimeDataFormClient({
+        baseUrl: "http://127.0.0.1:3003/",
+        appId: "app-demo",
+        env: "preview",
+        fetchImpl: async (input) => {
+            const url = String(input);
+            calls.push(url);
+            if (url === "http://127.0.0.1:3003/api/public/apps/app-demo/data-form/resources?env=preview") {
+                return jsonResponse({ resources: [] });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    await client.listResources();
+    assert.deepEqual(calls, [
+        "http://127.0.0.1:3003/api/public/apps/app-demo/data-form/resources?env=preview"
+    ]);
+});
+test("runtime data form client infers preview from tenant-scoped preview base url", async () => {
+    const calls = [];
+    const client = new RuntimeDataFormClient({
+        baseUrl: "https://runtime.example.com/previews/t-jason-workspace/app-demo/rel-123/",
+        appId: "app-demo",
+        fetchImpl: async (input) => {
+            const url = String(input);
+            calls.push(url);
+            if (url === "https://runtime.example.com/previews/t-jason-workspace/app-demo/rel-123/api/public/apps/app-demo/data-form/resources?env=preview") {
+                return jsonResponse({ resources: [] });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    await client.listResources();
+    assert.deepEqual(calls, [
+        "https://runtime.example.com/previews/t-jason-workspace/app-demo/rel-123/api/public/apps/app-demo/data-form/resources?env=preview"
+    ]);
+});
+test("runtime data form client infers preview from explicit publicBaseUrl when baseUrl is request origin", async () => {
+    const calls = [];
+    const client = new RuntimeDataFormClient({
+        baseUrl: "https://runtime.example.com/",
+        publicBaseUrl: "https://runtime.example.com/previews/t-jason-workspace/app-demo/rel-123/",
+        appId: "app-demo",
+        fetchImpl: async (input) => {
+            const url = String(input);
+            calls.push(url);
+            if (url === "https://runtime.example.com/api/public/apps/app-demo/data-form/resources?env=preview") {
+                return jsonResponse({ resources: [] });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    await client.listResources();
+    assert.deepEqual(calls, [
+        "https://runtime.example.com/api/public/apps/app-demo/data-form/resources?env=preview"
+    ]);
+});
+test("runtime data form client infers preview from routed preview base url", async () => {
+    const calls = [];
+    const client = new RuntimeDataFormClient({
+        baseUrl: "https://runtime.example.com/previews/r/t-jason-workspace/app-demo/rel-123/",
+        appId: "app-demo",
+        fetchImpl: async (input) => {
+            const url = String(input);
+            calls.push(url);
+            if (url === "https://runtime.example.com/previews/r/t-jason-workspace/app-demo/rel-123/api/public/apps/app-demo/data-form/resources?env=preview") {
+                return jsonResponse({ resources: [] });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    await client.listResources();
+    assert.deepEqual(calls, [
+        "https://runtime.example.com/previews/r/t-jason-workspace/app-demo/rel-123/api/public/apps/app-demo/data-form/resources?env=preview"
+    ]);
+});
+test("runtime data form client falls back to browser runtime config when options only carry request origin", async () => {
+    const previousWindow = globalThis.window;
+    globalThis.window = {
+        __PLATFORM_RUNTIME_CONFIG__: {
+            publicBaseUrl: "https://runtime.example.com/previews/r/t-jason-workspace/app-demo/rel-123/",
+            mode: "preview"
+        }
+    };
+    try {
+        const calls = [];
+        const client = new RuntimeDataFormClient({
+            baseUrl: "https://runtime.example.com/",
+            appId: "app-demo",
+            fetchImpl: async (input) => {
+                const url = String(input);
+                calls.push(url);
+                if (url === "https://runtime.example.com/api/public/apps/app-demo/data-form/resources?env=preview") {
+                    return jsonResponse({ resources: [] });
+                }
+                throw new Error(`Unexpected fetch url: ${url}`);
+            }
+        });
+        await client.listResources();
+        assert.deepEqual(calls, [
+            "https://runtime.example.com/api/public/apps/app-demo/data-form/resources?env=preview"
+        ]);
+    }
+    finally {
+        if (previousWindow === undefined) {
+            delete globalThis.window;
+        }
+        else {
+            globalThis.window = previousWindow;
+        }
+    }
+});
+test("compiled browser data form client is self-contained for vendored templates", async () => {
+    const compiled = await readFile(new URL("../../dist/data-form/client.js", import.meta.url), "utf8");
+    assert.doesNotMatch(compiled, /@platform\/url-contract/u);
+});

package/runtime-sdk/dist/data-form/contracts.d.ts

@@ -0,0 +1,10 @@
+import type { DataFormRuntimeListQuery } from "./types.js";
+export declare const DATA_FORM_RUNTIME_ROUTE_PREFIX: "/api/public/apps";
+export declare const DEFAULT_DATA_FORM_RUNTIME_PAGE = 1;
+export declare const DEFAULT_DATA_FORM_RUNTIME_PAGE_SIZE = 20;
+export declare function buildDataFormRuntimeBasePath(appId: string): string;
+export declare function buildDataFormRuntimeResourcesPath(appId: string): string;
+export declare function buildDataFormRuntimeSchemaPath(appId: string, resourceKey: string): string;
+export declare function buildDataFormRuntimeRecordsPath(appId: string, resourceKey: string): string;
+export declare function buildDataFormRuntimeRecordPath(appId: string, resourceKey: string, recordId: string): string;
+export declare function normalizeDataFormRuntimeListQuery(query: DataFormRuntimeListQuery): Required<DataFormRuntimeListQuery>;

package/runtime-sdk/dist/data-form/contracts.js

@@ -0,0 +1,33 @@
+export const DATA_FORM_RUNTIME_ROUTE_PREFIX = "/api/public/apps";
+export const DEFAULT_DATA_FORM_RUNTIME_PAGE = 1;
+export const DEFAULT_DATA_FORM_RUNTIME_PAGE_SIZE = 20;
+export function buildDataFormRuntimeBasePath(appId) {
+    return `${DATA_FORM_RUNTIME_ROUTE_PREFIX}/${encodeURIComponent(appId)}/data-form`;
+}
+export function buildDataFormRuntimeResourcesPath(appId) {
+    return `${buildDataFormRuntimeBasePath(appId)}/resources`;
+}
+export function buildDataFormRuntimeSchemaPath(appId, resourceKey) {
+    return `${buildDataFormRuntimeResourcesPath(appId)}/${encodeURIComponent(resourceKey)}/schema`;
+}
+export function buildDataFormRuntimeRecordsPath(appId, resourceKey) {
+    return `${buildDataFormRuntimeResourcesPath(appId)}/${encodeURIComponent(resourceKey)}/records`;
+}
+export function buildDataFormRuntimeRecordPath(appId, resourceKey, recordId) {
+    return `${buildDataFormRuntimeRecordsPath(appId, resourceKey)}/${encodeURIComponent(recordId)}`;
+}
+export function normalizeDataFormRuntimeListQuery(query) {
+    return {
+        page: normalizePositiveInteger(query.page, DEFAULT_DATA_FORM_RUNTIME_PAGE),
+        page_size: normalizePositiveInteger(query.page_size, DEFAULT_DATA_FORM_RUNTIME_PAGE_SIZE),
+        owner_scope: query.owner_scope === "all" ? "all" : "me",
+        q: typeof query.q === "string" ? query.q.trim() : ""
+    };
+}
+function normalizePositiveInteger(value, fallback) {
+    if (!Number.isFinite(value) || value === undefined) {
+        return fallback;
+    }
+    const normalized = Math.floor(value);
+    return normalized > 0 ? normalized : fallback;
+}

package/runtime-sdk/dist/data-form/index.d.ts

@@ -0,0 +1,3 @@
+export { RuntimeDataFormClient } from "./client.js";
+export { buildDataFormRuntimeBasePath, buildDataFormRuntimeRecordPath, buildDataFormRuntimeRecordsPath, buildDataFormRuntimeResourcesPath, buildDataFormRuntimeSchemaPath, DEFAULT_DATA_FORM_RUNTIME_PAGE, DEFAULT_DATA_FORM_RUNTIME_PAGE_SIZE, normalizeDataFormRuntimeListQuery } from "./contracts.js";
+export type { DataFormRuntimeCreateRecordInput, DataFormRuntimeListQuery, DataFormRuntimeRecord, DataFormRuntimeRecordListResponse, DataFormRuntimeRecordValues, DataFormRuntimeResourceListResponse, DataFormRuntimeResourceSummary, DataFormRuntimeSchemaResponse, DataFormRuntimeUpdateRecordInput } from "./types.js";

package/runtime-sdk/dist/data-form/index.js

@@ -0,0 +1,2 @@
+export { RuntimeDataFormClient } from "./client.js";
+export { buildDataFormRuntimeBasePath, buildDataFormRuntimeRecordPath, buildDataFormRuntimeRecordsPath, buildDataFormRuntimeResourcesPath, buildDataFormRuntimeSchemaPath, DEFAULT_DATA_FORM_RUNTIME_PAGE, DEFAULT_DATA_FORM_RUNTIME_PAGE_SIZE, normalizeDataFormRuntimeListQuery } from "./contracts.js";

package/runtime-sdk/dist/data-form/types.d.ts

@@ -0,0 +1,110 @@
+export type DataFormAccessScope = "public" | "own" | "admin";
+export type DataFormAccessPolicy = {
+    create: DataFormAccessScope;
+    read: DataFormAccessScope;
+    update: DataFormAccessScope;
+};
+export type DataFormResourceKind = "anonymous_submission" | "end_user_owned" | "admin_managed";
+export type DataFormOwnerType = "none" | "identity";
+export type DataFormResourceOwnerType = "app" | "tenant";
+export type DataFormSharingMode = "app_scoped" | "shared";
+export type DataFormConsumerAccessMode = "read_only" | "read_write";
+export type DataFormFieldValidation = {
+    required?: boolean;
+    min_length?: number;
+    max_length?: number;
+    pattern?: string | null;
+    min?: number;
+    max?: number;
+    step?: number;
+    min_date?: string | null;
+    max_date?: string | null;
+    max_count?: number;
+    max_size?: number;
+    allowed_protocols?: string[];
+};
+export type DataFormFieldUi = {
+    multiline?: boolean;
+    with_time?: boolean;
+    number_kind?: "integer" | "decimal";
+    widget?: string;
+};
+export type DataFormFieldAccept = {
+    mime_types?: string[];
+    extensions?: string[];
+};
+export type DataFormFieldOption = {
+    label: string;
+    value: string;
+};
+export type DataFormFieldOptions = {
+    values?: DataFormFieldOption[];
+};
+export type DataFormFieldSpec = {
+    name: string;
+    label: string;
+    type: string;
+    required: boolean;
+    default: unknown;
+    description: string;
+    order: number;
+    readonly?: boolean;
+    system_managed?: boolean;
+    validation?: DataFormFieldValidation;
+    options?: DataFormFieldOptions;
+    relation_target?: {
+        collection: string;
+    } | null;
+    accept?: DataFormFieldAccept;
+    ui?: DataFormFieldUi;
+    content_format?: string;
+};
+export type DataFormRuntimeListQuery = {
+    page?: number;
+    page_size?: number;
+    owner_scope?: "me" | "all";
+    q?: string;
+};
+export type DataFormRuntimeRecordValues = Record<string, unknown>;
+export type DataFormRuntimeResourceSummary = {
+    resource_key: string;
+    display_name: string;
+    resource_kind: DataFormResourceKind;
+    owner_type: DataFormOwnerType;
+    resource_owner_type: DataFormResourceOwnerType;
+    resource_owner_id?: string;
+    sharing_mode: DataFormSharingMode;
+    consumer_app_ids?: string[];
+    consumer_access: DataFormConsumerAccessMode;
+    access_policy: DataFormAccessPolicy;
+};
+export type DataFormRuntimeSchemaResponse = {
+    resource: DataFormRuntimeResourceSummary & {
+        fields: DataFormFieldSpec[];
+        description?: string;
+    };
+};
+export type DataFormRuntimeResourceListResponse = {
+    resources: DataFormRuntimeResourceSummary[];
+};
+export type DataFormRuntimeRecord = {
+    record_id: string;
+    resource_key: string;
+    owner_identity_id: string | null;
+    values: DataFormRuntimeRecordValues;
+    created_at: string;
+    updated_at: string;
+};
+export type DataFormRuntimeRecordListResponse = {
+    items: DataFormRuntimeRecord[];
+    page: number;
+    page_size: number;
+    total: number;
+    has_more: boolean;
+};
+export type DataFormRuntimeCreateRecordInput = {
+    values: DataFormRuntimeRecordValues;
+};
+export type DataFormRuntimeUpdateRecordInput = {
+    values: DataFormRuntimeRecordValues;
+};

package/runtime-sdk/dist/data-form/types.js

@@ -0,0 +1 @@
+export {};

package/runtime-sdk/dist/http.d.ts

@@ -0,0 +1,27 @@
+export interface RuntimeSdkOptions {
+    baseUrl: string;
+    publicBaseUrl?: string;
+    appId: string;
+    env?: "preview" | "prod";
+    fetchImpl?: typeof fetch;
+    getHeaders?: () => HeadersInit | Promise<HeadersInit>;
+}
+export declare class RuntimeApiError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    readonly detail?: Record<string, unknown> | undefined;
+    readonly requestId?: string | undefined;
+    constructor(message: string, status: number, code?: string | undefined, detail?: Record<string, unknown> | undefined, requestId?: string | undefined);
+}
+export declare class BaseRuntimeSdk {
+    protected readonly options: RuntimeSdkOptions;
+    protected readonly fetchImpl: typeof fetch;
+    constructor(options: RuntimeSdkOptions);
+    protected buildAppPath(path: string): string;
+    protected requestApp<T>(path: string, init?: RequestInit): Promise<T>;
+    protected requestVoid(path: string, init?: RequestInit): Promise<void>;
+    protected requestVoidUrl(url: URL, init?: RequestInit): Promise<void>;
+    protected buildRequestUrl(path: string): URL;
+    protected request<T>(path: string, init?: RequestInit): Promise<T>;
+    private fetchResponse;
+}

package/runtime-sdk/dist/http.js

@@ -0,0 +1,126 @@
+export class RuntimeApiError extends Error {
+    status;
+    code;
+    detail;
+    requestId;
+    constructor(message, status, code, detail, requestId) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.detail = detail;
+        this.requestId = requestId;
+        this.name = "RuntimeApiError";
+    }
+}
+export class BaseRuntimeSdk {
+    options;
+    fetchImpl;
+    constructor(options) {
+        this.options = options;
+        const providedFetch = options.fetchImpl;
+        this.fetchImpl = ((input, init) => {
+            if (providedFetch) {
+                return providedFetch(input, init);
+            }
+            return fetch(input, init);
+        });
+    }
+    buildAppPath(path) {
+        return `/api/public/apps/${encodeURIComponent(this.options.appId)}${path}`;
+    }
+    async requestApp(path, init = {}) {
+        return this.request(this.buildAppPath(path), init);
+    }
+    async requestVoid(path, init = {}) {
+        const response = await this.fetchResponse(this.buildRequestUrl(path), init);
+        if (response.ok) {
+            return;
+        }
+        const payload = (await parseJsonResponse(response));
+        const error = payload.error;
+        throw new RuntimeApiError(error?.message ?? `Request failed: ${response.status}`, response.status, error?.code, payload.detail, payload.request_id);
+    }
+    async requestVoidUrl(url, init = {}) {
+        const response = await this.fetchResponse(url, init);
+        if (response.ok) {
+            return;
+        }
+        const payload = (await parseJsonResponse(response));
+        const error = payload.error;
+        throw new RuntimeApiError(error?.message ?? `Request failed: ${response.status}`, response.status, error?.code, payload.detail, payload.request_id);
+    }
+    buildRequestUrl(path) {
+        const normalizedPath = typeof path === "string" ? path.replace(/^\/+/, "") : "";
+        const baseUrl = normalizeRuntimeBaseUrl(this.options.baseUrl);
+        return new URL(normalizedPath, baseUrl);
+    }
+    async request(path, init = {}) {
+        const response = await this.fetchResponse(this.buildRequestUrl(path), init);
+        const payload = (await parseJsonResponse(response));
+        if (!response.ok) {
+            const errorPayload = payload;
+            const error = errorPayload.error;
+            throw new RuntimeApiError(error?.message ?? `Request failed: ${response.status}`, response.status, error?.code, errorPayload.detail, errorPayload.request_id);
+        }
+        return payload;
+    }
+    async fetchResponse(url, init = {}) {
+        const headers = new Headers(init.headers);
+        if (!headers.has("Content-Type") && shouldDefaultJsonContentType(init.body)) {
+            headers.set("Content-Type", "application/json");
+        }
+        const extraHeaders = await this.options.getHeaders?.();
+        if (extraHeaders) {
+            const resolved = new Headers(extraHeaders);
+            resolved.forEach((value, key) => {
+                if (!headers.has(key)) {
+                    headers.set(key, value);
+                }
+            });
+        }
+        return this.fetchImpl(url, {
+            ...init,
+            headers
+        });
+    }
+}
+function shouldDefaultJsonContentType(body) {
+    if (body === undefined || body === null) {
+        return false;
+    }
+    if (typeof body === "string") {
+        return true;
+    }
+    if (typeof FormData !== "undefined" && body instanceof FormData) {
+        return false;
+    }
+    if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) {
+        return false;
+    }
+    if (typeof Blob !== "undefined" && body instanceof Blob) {
+        return false;
+    }
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+        return false;
+    }
+    return false;
+}
+function normalizeRuntimeBaseUrl(baseUrl) {
+    const normalized = typeof baseUrl === "string" ? baseUrl.trim() : "";
+    if (!normalized) {
+        return "/";
+    }
+    return normalized.endsWith("/") ? normalized : `${normalized}/`;
+}
+async function parseJsonResponse(response) {
+    const text = await response.text();
+    if (text.trim().length === 0) {
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new RuntimeApiError(response.ok ? "Invalid JSON response" : `Request failed: ${response.status}`, response.status);
+    }
+}

package/runtime-sdk/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { PlatformRuntimeSdk } from "./client.js";
+export { RuntimeApiError, type RuntimeSdkOptions } from "./http.js";
+export { createBrowserRuntimeApp, type BrowserRuntimeAppOptions } from "./browser/app.js";
+export { normalizeCmsMediaUrl, resolveCmsCoverImageSet, resolveCmsCoverImageUrl, resolveCmsImageSet, resolveCmsImageUrl, type RuntimeCmsMediaUrlOptions } from "./cms/media.js";
+export { buildCmsCategoryNameMap, resolveCmsCategoryName, resolveCmsItemCategoryName, resolveCmsItemTagLabels, resolveCmsTagLabels } from "./cms/taxonomy.js";
+export { RuntimeBlobClient, type RuntimeBlobBinaryBody } from "./blob/client.js";
+export { classifyBrowserRuntimeError, classifyBrowserWorkflowError, getBrowserRuntimeErrorMessage, getBrowserWorkflowErrorMessage, resolveEndUserAccess, type BrowserRuntimeAccessKind, type BrowserRuntimeAccessResolution, type BrowserRuntimeErrorKind, type BrowserRuntimeErrorResolution, type BrowserWorkflowErrorKind, type BrowserWorkflowErrorResolution, } from "./browser/errors.js";
+export { buildEndUserSessionStorageKey, createBrowserRuntimeSdk, createBrowserSessionStore, type BrowserSessionStore, type BrowserSessionStoreOptions } from "./session/browser.js";
+export { RuntimeAuthClient } from "./auth/client.js";
+export { RuntimeCmsClient } from "./cms/client.js";
+export * from "./data-form/index.js";
+export * from "./notification/index.js";
+export { RuntimeNotificationClient } from "./notification/client.js";
+export { RuntimeWorkflowClient } from "./workflow/client.js";
+export type { RuntimeEndUserAuthMe, RuntimeEndUserRoleRecord } from "./types/auth.js";
+export type { BlobDisplayValue, DataFormHydratedBlobValue, RuntimeBlobRef, RuntimeBlobHydrateResponse, RuntimeBlobUploadTicket, RuntimeBlobUploadSession, RuntimeCompleteBlobUploadInput, RuntimeCompleteBlobUploadResult, RuntimeCreateBlobUploadSessionInput, RuntimeHydrateBlobRefsInput, RuntimeHydrateRecordBlobsInput } from "./types/object-storage.js";
+export type { RuntimeCmsCategoryNode, RuntimeCmsCategoryTreeResponse, RuntimeCmsCollectionListEntry, RuntimeCmsCollectionListResponse, RuntimeCmsCollectionMetaResponse, RuntimeCmsCollectionSpec, RuntimeCmsDeliveryListResponse, RuntimeCmsImageSet, RuntimeCmsItemDeliveryPayload, RuntimeCmsPresentation, RuntimeCmsRelationSummary } from "./types/cms.js";
+export type { RuntimeNotificationAnnouncements, RuntimeNotificationCommandResult, RuntimeNotificationInboxItem, RuntimeNotificationInboxItemStatus, RuntimeNotificationInboxItemType, RuntimeNotificationInboxList, RuntimeNotificationUnreadCount } from "./types/notification.js";
+export type { RuntimeWorkflowActionItem, RuntimeWorkflowActionResult, RuntimeWorkflowObjectState, RuntimeWorkflowStartResult, RuntimeWorkflowTaskList, RuntimeWorkflowTaskItem, RuntimeWorkflowTimelineItem } from "./types/workflow.js";