@base44-preview/sdk 0.8.48-pr.286.f67ed26 → 0.8.48-pr.287.fd215cb

package/README.md

@@ -151,12 +151,3 @@ npm run create-docs
 cd docs
 mintlify dev
 ```
-
-### Platform browser subscriptions
-
-The separate `@base44/sdk/platform/client` entry point subscribes to public builder
-updates through the white-label socket. It supports typed events, bounded delivery,
-and reconnect replay using browser credentials supplied by your backend.
-See [setup, public contract and recovery](platform-docs/client.md) and the
-[TypeScript example](examples/platform-client.ts). Backend token integration and
-workspace rollout are prerequisites; never use an API key in the browser.

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
 export type { Base44Client, CreateClientAnalyticsConfig, CreateClientConfig, CreateClientOptions, Base44ErrorJSON, };
 export * from "./types.js";
-export type { DeleteManyResult, DeleteResult, EntitiesModule, EntityFilterOperators, EntityFilterQuery, EntityFilterValue, EntityHandler, EntityRecord, EntityTypeRegistry, ImportResult, RealtimeEventType, RealtimeEvent, RealtimeCallback, SortField, UpdateManyResult, } from "./modules/entities.types.js";
+export type { DeleteManyResult, DeleteResult, EntitiesModule, EntityAggregateResult, EntityAggregateSpec, EntityDateBucketUnit, EntityDistinctOptions, EntityFilterOperators, EntityFilterQuery, EntityFilterValue, EntityHandler, EntityListOptions, EntityPage, EntityRecord, EntityTypeRegistry, EntityUpsertOptions, EntityUpsertResult, ImportResult, RealtimeEventType, RealtimeEvent, RealtimeCallback, SortField, UpdateManyResult, } from "./modules/entities.types.js";
 export type { AuthModule, LoginResponse, RegisterParams, VerifyOtpParams, ChangePasswordParams, ResetPasswordParams, User, } from "./modules/auth.types.js";
 export type { IntegrationsModule, IntegrationEndpointFunction, CoreIntegrations, InvokeLLMParams, GenerateImageParams, GenerateImageResult, UploadFileParams, UploadFileResult, SendEmailParams, SendEmailResult, ExtractDataFromUploadedFileParams, ExtractDataFromUploadedFileResult, UploadPrivateFileParams, UploadPrivateFileResult, CreateFileSignedUrlParams, CreateFileSignedUrlResult, } from "./modules/integrations.types.js";
 export type { FunctionsModule, FunctionName, FunctionNameRegistry, } from "./modules/functions.types.js";

package/dist/modules/entities.js

@@ -41,6 +41,10 @@ function parseRealtimeMessage(dataStr) {
         return null;
     }
 }
+const DEFAULT_PAGE_LIMIT = 100;
+function isPageOptions(value) {
+    return typeof value === "object" && value !== null;
+}
 /**
  * Creates a handler for a specific entity.
  *
@@ -53,34 +57,51 @@ function parseRealtimeMessage(dataStr) {
  */
 function createEntityHandler(axios, appId, entityName, getSocket) {
     const baseURL = `/apps/${appId}/entities/${entityName}`;
+    const fieldsParam = (fields) => Array.isArray(fields) ? fields.join(",") : fields;
+    // GET /{entity}: the array form shared by list() and filter()
+    const readArray = (sort, limit, skip, fields, query) => {
+        const params = {};
+        if (query)
+            params.q = JSON.stringify(query);
+        if (sort)
+            params.sort = sort;
+        if (limit)
+            params.limit = limit;
+        if (skip)
+            params.skip = skip;
+        if (fields)
+            params.fields = fieldsParam(fields);
+        return axios.get(baseURL, { params });
+    };
+    // GET /{entity}/v2/list: one cursor page of records or distinct values, shared by list(options) and filter(query, options)
+    const readPage = (options, query) => {
+        const params = {};
+        if (query)
+            params.q = JSON.stringify(query);
+        params.limit = options.limit || DEFAULT_PAGE_LIMIT;
+        if (options.cursor)
+            params.cursor = options.cursor;
+        if ("distinct" in options) {
+            params.distinct = options.distinct;
+        }
+        else {
+            if (options.sort)
+                params.sort = options.sort;
+            if (options.fields)
+                params.fields = fieldsParam(options.fields);
+        }
+        return axios.get(`${baseURL}/v2/list`, { params });
+    };
     return {
-        // List entities with optional pagination and sorting
-        async list(sort, limit, skip, fields) {
-            const params = {};
-            if (sort)
-                params.sort = sort;
-            if (limit)
-                params.limit = limit;
-            if (skip)
-                params.skip = skip;
-            if (fields)
-                params.fields = Array.isArray(fields) ? fields.join(",") : fields;
-            return axios.get(baseURL, { params });
-        },
-        // Filter entities based on query
-        async filter(query, sort, limit, skip, fields) {
-            const params = {
-                q: JSON.stringify(query),
-            };
-            if (sort)
-                params.sort = sort;
-            if (limit)
-                params.limit = limit;
-            if (skip)
-                params.skip = skip;
-            if (fields)
-                params.fields = Array.isArray(fields) ? fields.join(",") : fields;
-            return axios.get(baseURL, { params });
+        // list(sort, limit, skip, fields) returns an array; list(options) returns one cursor page.
+        async list(...args) {
+            const [sort, limit, skip, fields] = args;
+            return isPageOptions(sort) ? readPage(sort) : readArray(sort, limit, skip, fields);
+        },
+        // filter(query, sort, limit, skip, fields) returns an array; filter(query, options) returns one cursor page.
+        async filter(query, ...args) {
+            const [sort, limit, skip, fields] = args;
+            return isPageOptions(sort) ? readPage(sort, query) : readArray(sort, limit, skip, fields, query);
         },
         // Get entity by ID
         async get(id) {
@@ -110,6 +131,22 @@ function createEntityHandler(axios, appId, entityName, getSocket) {
         async updateMany(query, data) {
             return axios.patch(`${baseURL}/update-many`, { query, data });
         },
+        // Count entities matching a query
+        async count(query) {
+            const params = {};
+            if (query)
+                params.q = JSON.stringify(query);
+            const result = await axios.get(`${baseURL}/count`, { params });
+            return result.count;
+        },
+        // Server-side group-by aggregation
+        async aggregate(spec) {
+            return axios.post(`${baseURL}/aggregate`, spec);
+        },
+        // Create or update by a natural key
+        async upsert(records, options) {
+            return axios.post(`${baseURL}/upsert`, { records, key: options.key });
+        },
         // Update multiple entities by ID, each with its own update data
         async bulkUpdate(data) {
             return axios.put(`${baseURL}/bulk`, data);

package/dist/modules/entities.types.d.ts

@@ -50,6 +50,130 @@ export interface UpdateManyResult {
     /** Whether there are more entities matching the query that were not updated in this batch. When `true`, call `updateMany` again with the same query to update the next batch. */
     has_more: boolean;
 }
+/**
+ * Options object accepted by {@linkcode EntityHandler.list | list()} and
+ * {@linkcode EntityHandler.filter | filter()} to read one cursor page.
+ *
+ * @typeParam T - Entity record type.
+ * @typeParam K - The fields to include in each record.
+ */
+export interface EntityListOptions<T, K extends keyof T = keyof T> {
+    /** Sort parameter, such as `'-created_date'` for descending. Defaults to `'-created_date'`. */
+    sort?: SortField<T>;
+    /** Maximum number of records per page, up to 5,000. Defaults to 100. */
+    limit?: number;
+    /**
+     * `next_cursor` from the previous page. Omit or pass `null` for the first page.
+     *
+     * The token carries the query, sort and fields of the walk, so a later page needs only
+     * `cursor` and `limit`. Passing a different query, sort or fields with a cursor is an error.
+     */
+    cursor?: string | null;
+    /** Array of field names to include in each record. Defaults to all fields. */
+    fields?: K[];
+}
+/**
+ * Options object accepted by {@linkcode EntityHandler.list | list()} and
+ * {@linkcode EntityHandler.filter | filter()} to read the distinct values of one field
+ * instead of records.
+ *
+ * @typeParam T - Entity record type.
+ * @typeParam K - The field whose distinct values to read.
+ */
+export interface EntityDistinctOptions<T, K extends keyof T = keyof T> {
+    /** Field whose distinct values to return, in ascending order. Array fields contribute each element. */
+    distinct: K;
+    /** Maximum number of values per page, up to 1,000. Defaults to 100. */
+    limit?: number;
+    /** `next_cursor` from the previous page. Omit or pass `null` for the first page. The token carries the query and field. */
+    cursor?: string | null;
+}
+/**
+ * One page of records, returned by {@linkcode EntityHandler.list | list()} and
+ * {@linkcode EntityHandler.filter | filter()} when called with an options object.
+ *
+ * @typeParam T - Record type of the items.
+ */
+export interface EntityPage<T> {
+    /** The page's records in the requested sort order, or the distinct values in ascending order. */
+    items: T[];
+    /** Pass as `cursor` to get the next page. `null` on the last page. */
+    next_cursor: string | null;
+    /** Whether records remain after this page. */
+    has_more: boolean;
+}
+/**
+ * Time unit for {@linkcode EntityAggregateSpec.dateBucket | dateBucket}.
+ */
+export type EntityDateBucketUnit = "day" | "week" | "month" | "year";
+/**
+ * Describes what {@linkcode EntityHandler.aggregate | aggregate()} computes.
+ *
+ * Name the fields to group by and the measures to compute; the server does the work and
+ * returns one row per group. Field names are the entity's own field names.
+ *
+ * @typeParam T - Entity record type.
+ */
+export interface EntityAggregateSpec<T> {
+    /** Filter applied before grouping, in the same form {@linkcode EntityHandler.filter | filter()} accepts. Defaults to all records. */
+    query?: EntityFilterQuery<T>;
+    /** Field, or up to four fields, to group by. Omit to get one total row. */
+    groupBy?: (keyof T & string) | (keyof T & string)[];
+    /** Group by a time bucket of a date field. `created_date` and `updated_date` support every unit; date fields of your schema support `day`, `month` and `year`. */
+    dateBucket?: {
+        field: keyof T & string;
+        unit: EntityDateBucketUnit;
+    };
+    /** Whether to include the number of records per group as `count`. Defaults to `true`. */
+    count?: boolean;
+    /** Field, or fields, to sum. Each appears in the rows as `sum_<field>`. */
+    sum?: (keyof T & string) | (keyof T & string)[];
+    /** Field, or fields, to average. Each appears in the rows as `avg_<field>`. */
+    avg?: (keyof T & string) | (keyof T & string)[];
+    /** Field, or fields, to take the minimum of. Each appears in the rows as `min_<field>`. */
+    min?: (keyof T & string) | (keyof T & string)[];
+    /** Field, or fields, to take the maximum of. Each appears in the rows as `max_<field>`. */
+    max?: (keyof T & string) | (keyof T & string)[];
+    /** Field whose distinct values to count per group, returned as `count_distinct_<field>`. */
+    countDistinct?: keyof T & string;
+    /** Filter on the computed fields, applied after grouping. For example `{ count: { $gt: 1 } }` keeps only duplicated groups. */
+    having?: Record<string, any>;
+    /** Computed or group field to sort the rows by, with a `-` prefix for descending. For example `'-count'`. */
+    sort?: string;
+    /** Maximum number of rows, up to 1,000. Defaults to 1,000. */
+    limit?: number;
+}
+/**
+ * Rows returned by {@linkcode EntityHandler.aggregate | aggregate()}.
+ */
+export interface EntityAggregateResult {
+    /** One row per group: the group fields by name, then `count`, `sum_<field>`, `avg_<field>`, `min_<field>`, `max_<field>` or `count_distinct_<field>`. */
+    rows: Record<string, any>[];
+    /** `true` when more groups exist than `limit` allowed. */
+    truncated: boolean;
+}
+/**
+ * Options for {@linkcode EntityHandler.upsert | upsert()}.
+ *
+ * @typeParam T - Entity record type.
+ */
+export interface EntityUpsertOptions<T> {
+    /** Field, or fields, that identify a record. A record whose key values match an existing record updates it; any other record is created. */
+    key: (keyof T & string) | (keyof T & string)[];
+}
+/**
+ * Result returned by {@linkcode EntityHandler.upsert | upsert()}.
+ *
+ * @typeParam T - Entity record type.
+ */
+export interface EntityUpsertResult<T = any> {
+    /** Number of records that were created. */
+    created: number;
+    /** Number of existing records that were updated. */
+    updated: number;
+    /** The written records, created and updated, as they now exist. */
+    records: T[];
+}
 /**
  * Result returned when importing entities from a file.
  *
@@ -211,14 +335,18 @@ export interface EntityHandler<T = any> {
      * Retrieves all records of this type with support for sorting,
      * pagination, and field selection.
      *
-     * **Note:** The maximum limit is 5,000 items per request.
+     * **Note:** The maximum limit is 5,000 items per request. To read more than
+     * one page, pass an {@linkcode EntityListOptions | options object} with a
+     * `cursor` instead of `skip`: every page costs the same however deep you are,
+     * and records deleted between pages never shift the boundary. `skip` is kept
+     * for existing code and is deprecated for loops.
      *
      * @typeParam K - The fields to include in the response. Defaults to all fields.
      * @param sort - Sort parameter, such as `'-created_date'` for descending. Defaults to `'-created_date'`.
-     * @param limit - Maximum number of results to return. Defaults to `50`.
-     * @param skip - Number of results to skip for pagination. Defaults to `0`.
+     * @param limit - Maximum number of results to return. Defaults to `5000`.
+     * @param skip - Number of results to skip for pagination. Defaults to `0`. Deprecated for loops; use a cursor.
      * @param fields - Array of field names to include in the response. Defaults to all fields.
-     * @returns Promise resolving to an array of records with selected fields.
+     * @returns Promise resolving to an array of records with selected fields. When called with an options object, resolves instead to an {@linkcode EntityPage | EntityPage} with `items`, `next_cursor` and `has_more`; with a `distinct` option the items are the field's values.
      *
      * @example
      * ```typescript
@@ -244,15 +372,39 @@ export interface EntityHandler<T = any> {
      * // Get only specific fields
      * const fields = await base44.entities.MyEntity.list('-created_date', 10, 0, ['name', 'status']);
      * ```
+     *
+     * @example
+     * ```typescript
+     * // Walk every record with a cursor. Pass an options object instead of
+     * // positional arguments to get a page with `next_cursor` and `has_more`.
+     * let page = await base44.entities.MyEntity.list({ sort: '-created_date', limit: 1000 });
+     * await exportRows(page.items);
+     * while (page.has_more) {
+     *   page = await base44.entities.MyEntity.list({ cursor: page.next_cursor, limit: 1000 });
+     *   await exportRows(page.items);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Distinct values of one field, instead of records
+     * const { items: categories } = await base44.entities.Product.list({ distinct: 'category' });
+     * ```
      */
     list<K extends keyof T = keyof T>(sort?: SortField<T>, limit?: number, skip?: number, fields?: K[]): Promise<Pick<T, K>[]>;
+    list<K extends keyof T>(options: EntityDistinctOptions<T, K>): Promise<EntityPage<T[K]>>;
+    list<K extends keyof T = keyof T>(options: EntityListOptions<T, K>): Promise<EntityPage<Pick<T, K>>>;
     /**
      * Filters records based on a query.
      *
      * Retrieves records that match specific criteria with support for
      * sorting, pagination, and field selection.
      *
-     * **Note:** The maximum limit is 5,000 items per request.
+     * **Note:** The maximum limit is 5,000 items per request. To read more than
+     * one page, pass an {@linkcode EntityListOptions | options object} with a
+     * `cursor` instead of `skip`: every page costs the same however deep you are,
+     * and records deleted between pages never shift the boundary. `skip` is kept
+     * for existing code and is deprecated for loops.
      *
      * @typeParam K - The fields to include in the response. Defaults to all fields.
      * @param query - Query object with field-value pairs. Each key should be a field name
@@ -261,10 +413,10 @@ export interface EntityHandler<T = any> {
      * for exact matches, `null` for null values, arrays as shorthand for matching any of the
      * provided values, or documented MongoDB query operators for advanced filtering.
      * @param sort - Sort parameter, such as `'-created_date'` for descending. Defaults to `'-created_date'`.
-     * @param limit - Maximum number of results to return. Defaults to `50`.
-     * @param skip - Number of results to skip for pagination. Defaults to `0`.
+     * @param limit - Maximum number of results to return. Defaults to `5000`.
+     * @param skip - Number of results to skip for pagination. Defaults to `0`. Deprecated for loops; use a cursor.
      * @param fields - Array of field names to include in the response. Defaults to all fields.
-     * @returns Promise resolving to an array of filtered records with selected fields.
+     * @returns Promise resolving to an array of filtered records with selected fields. When called with an options object, resolves instead to an {@linkcode EntityPage | EntityPage} with `items`, `next_cursor` and `has_more`; with a `distinct` option the items are the field's values.
      *
      * @example
      * ```typescript
@@ -341,8 +493,34 @@ export interface EntityHandler<T = any> {
      *   ['name', 'priority']
      * );
      * ```
+     *
+     * @example
+     * ```typescript
+     * // Walk all matching records with a cursor. Pass an options object as the
+     * // second argument to get a page with `next_cursor` and `has_more`.
+     * let page = await base44.entities.Order.filter(
+     *   { status: 'open' },
+     *   { sort: '-created_date', limit: 1000 }
+     * );
+     * await exportRows(page.items);
+     * while (page.has_more) {
+     *   page = await base44.entities.Order.filter({ status: 'open' }, { cursor: page.next_cursor, limit: 1000 });
+     *   await exportRows(page.items);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Distinct values of one field among the matching records
+     * const { items: agents } = await base44.entities.Order.filter(
+     *   { status: 'open' },
+     *   { distinct: 'agent_id' }
+     * );
+     * ```
      */
     filter<K extends keyof T = keyof T>(query: EntityFilterQuery<T>, sort?: SortField<T>, limit?: number, skip?: number, fields?: K[]): Promise<Pick<T, K>[]>;
+    filter<K extends keyof T>(query: EntityFilterQuery<T>, options: EntityDistinctOptions<T, K>): Promise<EntityPage<T[K]>>;
+    filter<K extends keyof T = keyof T>(query: EntityFilterQuery<T>, options: EntityListOptions<T, K>): Promise<EntityPage<Pick<T, K>>>;
     /**
      * Gets a single record by ID.
      *
@@ -549,6 +727,111 @@ export interface EntityHandler<T = any> {
      * ```
      */
     updateMany(query: Partial<T>, data: Record<string, Record<string, any>>): Promise<UpdateManyResult>;
+    /**
+     * Counts the records that match a query.
+     *
+     * Returns the number of records the current user can read, without fetching them.
+     * Use it for totals, badges and "page N of M" instead of listing records and
+     * measuring the array.
+     *
+     * @param query - Filter query, in the same form {@linkcode filter | filter()} accepts. Defaults to all records.
+     * @returns Promise resolving to the number of matching records.
+     *
+     * @example
+     * ```typescript
+     * // How many tasks are still open?
+     * const open = await base44.entities.Task.count({ status: 'open' });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Total records in the entity
+     * const total = await base44.entities.Task.count();
+     * ```
+     */
+    count(query?: EntityFilterQuery<T>): Promise<number>;
+    /**
+     * Computes counts, sums, averages, minimums, maximums or distinct counts, grouped by fields.
+     *
+     * Use it for dashboards, leaderboards and reports instead of loading every record
+     * and adding up in the browser. The server groups the records you can read and
+     * returns one row per group, up to 1,000 rows.
+     *
+     * @param spec - What to group by and what to compute. See {@linkcode EntityAggregateSpec | EntityAggregateSpec}.
+     * @returns Promise resolving to the rows and a `truncated` flag.
+     *
+     * @example
+     * ```typescript
+     * // Sales per agent this month, biggest first
+     * const { rows } = await base44.entities.Sale.aggregate({
+     *   query: { sale_date: { $gte: '2026-09-01' } },
+     *   groupBy: 'agent_id',
+     *   sum: 'amount',
+     *   sort: '-sum_amount'
+     * });
+     * // rows: [{ agent_id: 'a1', count: 42, sum_amount: 18250 }, ...]
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Records created per day
+     * const { rows } = await base44.entities.Visit.aggregate({
+     *   dateBucket: { field: 'created_date', unit: 'day' }
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Find duplicated external ids
+     * const { rows } = await base44.entities.Contact.aggregate({
+     *   groupBy: 'external_id',
+     *   having: { count: { $gt: 1 } }
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Unique visitors per page
+     * const { rows } = await base44.entities.PageView.aggregate({
+     *   groupBy: 'path',
+     *   countDistinct: 'session_id'
+     * });
+     * ```
+     */
+    aggregate(spec: EntityAggregateSpec<T>): Promise<EntityAggregateResult>;
+    /**
+     * Creates or updates records by a key of your own.
+     *
+     * Use this when you sync data from another system: name the field, or fields, that
+     * identify a record, and the server updates the records whose key already exists and
+     * creates the rest, in one call. You no longer need to list existing records to check
+     * for duplicates before writing.
+     *
+     * You can upsert up to 500 records per request. When two records in one call share a
+     * key, the last one wins. Updates merge the given fields into the existing record, like
+     * {@linkcode update | update()}.
+     *
+     * @param records - Array of record data objects. Each must carry a value for every key field.
+     * @param options - The key field or fields. See {@linkcode EntityUpsertOptions | EntityUpsertOptions}.
+     * @returns Promise resolving to the counts and the written records.
+     *
+     * @example
+     * ```typescript
+     * // Sync contacts from a CRM by their CRM id
+     * const result = await base44.entities.Contact.upsert(
+     *   crmContacts.map(c => ({ crm_id: c.id, name: c.name, email: c.email })),
+     *   { key: 'crm_id' }
+     * );
+     * console.log(`${result.created} new, ${result.updated} updated`);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Compound key
+     * await base44.entities.Inventory.upsert(rows, { key: ['sku', 'warehouse'] });
+     * ```
+     */
+    upsert(records: Partial<T>[], options: EntityUpsertOptions<T>): Promise<EntityUpsertResult<T>>;
     /**
      * Updates the specified records in a single request, each with its own data.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.48-pr.286.f67ed26",
+  "version": "0.8.48-pr.287.fd215cb",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,8 +9,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "npm run build:runtime && npm run build:platform",
-    "lint": "eslint src platform-src examples/platform-client.ts",
+    "build": "tsc",
+    "lint": "eslint src",
     "test": "npm run test:types && vitest run",
     "test:types": "tsc --noEmit -p tsconfig.type-tests.json",
     "test:unit": "vitest run tests/unit",
@@ -23,11 +23,7 @@
     "create-docs-local": "npm run create-docs && npm run copy-docs-local",
     "copy-docs-local": "node scripts/mintlify-post-processing/copy-to-local-docs.js",
     "create-docs:generate": "typedoc",
-    "create-docs:process": "node scripts/mintlify-post-processing/file-processing/file-processing.js",
-    "build:runtime": "tsc",
-    "build:platform": "tsc -p tsconfig.platform.json",
-    "docs:platform-client": "typedoc --options typedoc.platform-client.json",
-    "test:package": "npm run build && node --test tests/package/platform-client.test.mjs"
+    "create-docs:process": "node scripts/mintlify-post-processing/file-processing/file-processing.js"
   },
   "dependencies": {
     "axios": "^1.18.1",
@@ -67,36 +63,5 @@
   "bugs": {
     "url": "https://github.com/base44/javascript-sdk/issues"
   },
-  "homepage": "https://github.com/base44/javascript-sdk#readme",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./dist/*.d.ts": "./dist/*.d.ts",
-    "./dist/*.js": {
-      "types": "./dist/*.d.ts",
-      "default": "./dist/*.js"
-    },
-    "./dist/*": {
-      "types": "./dist/*.d.ts",
-      "default": "./dist/*.js"
-    },
-    "./package.json": "./package.json",
-    "./*": "./*",
-    "./platform/client": {
-      "types": "./dist/platform/client/index.d.ts",
-      "default": "./dist/platform/client/index.js"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      "platform/client": [
-        "dist/platform/client/index.d.ts"
-      ],
-      "*": [
-        "*"
-      ]
-    }
-  }
+  "homepage": "https://github.com/base44/javascript-sdk#readme"
 }

package/dist/platform/client/client.d.ts

@@ -1,35 +0,0 @@
-import type { PlatformClientOptions, PlatformSubscription, SubscriptionOptions } from "./types.js";
-/** Browser client for read-only platform app events. Constructing it opens no connection. */
-export declare class Base44PlatformClient {
-    private readonly socket;
-    private readonly subscriptions;
-    private readonly options;
-    private closed;
-    private needsFreshConnection;
-    private generation;
-    private authAttempt;
-    private cancelAuth?;
-    private connecting?;
-    private resolveConnect?;
-    private rejectConnect?;
-    /** Configure a dedicated connection. API keys belong exclusively on your backend. */
-    constructor(options: PlatformClientOptions);
-    /** Connect using a freshly obtained token. Resolves on CONNECT, not on app replay completion.
-     * Unexpected transport loss retries up to five times and rejoins active subscriptions.
-     * Call again after addressing a connection/auth failure; concurrent calls share one attempt.
-     */
-    connect(): Promise<void>;
-    /** Subscribe before or after connecting. One subscription per app, maximum eight.
-     * Events and boundary callbacks are awaited in order per app. Failed application,
-     * invalid frames or server errors end the subscription without advancing its cursor.
-     */
-    subscribe(appId: string, options: SubscriptionOptions): PlatformSubscription;
-    /** Stop delivery, cancel reconnection and release all listeners. Idempotent and terminal. */
-    close(): void;
-    private join;
-    private authenticate;
-    private clearConnecting;
-    private connectionError;
-    private serverError;
-    private protocolError;
-}

package/dist/platform/client/client.js

@@ -1,218 +0,0 @@
-import { io } from "socket.io-client";
-import { PlatformSocketError } from "./errors.js";
-import { appFromRoom, appPattern, decode, decodeJoined, errorCodes, eventApp, eventNames, object, roomFor } from "./protocol.js";
-import { notify, Subscription } from "./subscription.js";
-/** Browser client for read-only platform app events. Constructing it opens no connection. */
-export class Base44PlatformClient {
-    /** Configure a dedicated connection. API keys belong exclusively on your backend. */
-    constructor(options) {
-        this.subscriptions = new Map();
-        this.closed = false;
-        this.needsFreshConnection = false;
-        this.generation = 0;
-        this.authAttempt = 0;
-        const url = new URL(options.serverUrl);
-        if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || url.pathname !== "/") {
-            throw new TypeError("serverUrl must be an HTTP(S) origin without credentials, path, query or fragment");
-        }
-        this.options = { ...options };
-        this.socket = io(`${url.origin}/partner`, {
-            path: "/ws-whitelabel/socket.io/", transports: ["websocket"], autoConnect: false,
-            forceNew: true, reconnectionAttempts: 5, reconnectionDelay: 1000, reconnectionDelayMax: 10000,
-            timeout: 20000,
-            auth: (callback) => { void this.authenticate(callback); },
-        });
-        this.socket.on("connect", () => {
-            var _a;
-            const generation = ++this.generation;
-            this.needsFreshConnection = false;
-            for (const subscription of this.subscriptions.values())
-                this.join(subscription, generation);
-            (_a = this.resolveConnect) === null || _a === void 0 ? void 0 : _a.call(this);
-            this.clearConnecting();
-        });
-        this.socket.on("disconnect", (reason) => {
-            ++this.generation;
-            ++this.authAttempt;
-            if (reason === "io server disconnect")
-                this.connectionError(new PlatformSocketError("connection_failed"));
-        });
-        this.socket.on("connect_error", (error) => {
-            var _a;
-            this.connectionError(new PlatformSocketError(((_a = error.data) === null || _a === void 0 ? void 0 : _a.code) === "connection_denied" ? "connection_denied" : "connection_failed"));
-        });
-        this.socket.io.on("reconnect_failed", () => this.connectionError(new PlatformSocketError("connection_failed")));
-        this.socket.on("joined", (raw) => {
-            var _a;
-            try {
-                const joined = decodeJoined(raw);
-                (_a = this.subscriptions.get(appFromRoom(joined.room))) === null || _a === void 0 ? void 0 : _a.joined(joined);
-            }
-            catch (_b) {
-                this.protocolError(raw);
-            }
-        });
-        this.socket.on("error", (raw) => this.serverError(raw));
-        for (const type of eventNames)
-            this.socket.on(type, (raw) => {
-                var _a;
-                try {
-                    const appId = eventApp(type, raw);
-                    if (!appId)
-                        throw new Error("Invalid app");
-                    (_a = this.subscriptions.get(appId)) === null || _a === void 0 ? void 0 : _a.event(decode(type, appId, raw));
-                }
-                catch (_b) {
-                    this.protocolError(raw);
-                }
-            });
-    }
-    /** Connect using a freshly obtained token. Resolves on CONNECT, not on app replay completion.
-     * Unexpected transport loss retries up to five times and rejoins active subscriptions.
-     * Call again after addressing a connection/auth failure; concurrent calls share one attempt.
-     */
-    connect() {
-        if (this.closed)
-            return Promise.reject(new PlatformSocketError("client_closed"));
-        if (this.socket.connected)
-            return Promise.resolve();
-        if (this.connecting)
-            return this.connecting;
-        const promise = new Promise((resolve, reject) => {
-            this.resolveConnect = resolve;
-            this.rejectConnect = reject;
-        });
-        this.connecting = promise;
-        this.socket.connect();
-        return promise;
-    }
-    /** Subscribe before or after connecting. One subscription per app, maximum eight.
-     * Events and boundary callbacks are awaited in order per app. Failed application,
-     * invalid frames or server errors end the subscription without advancing its cursor.
-     */
-    subscribe(appId, options) {
-        if (this.closed)
-            throw new PlatformSocketError("client_closed");
-        if (!appPattern.test(appId))
-            throw new TypeError("appId must be 24 lowercase hexadecimal characters");
-        if (options.afterSeq !== undefined && (typeof options.afterSeq !== "string" || !options.afterSeq))
-            throw new TypeError("afterSeq must be a nonempty opaque cursor");
-        if (this.subscriptions.has(appId))
-            throw new TypeError("An app may only have one subscription per client");
-        if (this.subscriptions.size >= 8)
-            throw new PlatformSocketError("subscription_limit", appId);
-        const subscription = new Subscription(appId, { ...options }, () => {
-            this.subscriptions.delete(appId);
-            this.needsFreshConnection = true;
-            if (this.socket.connected)
-                this.socket.emit("leave", roomFor(appId));
-        });
-        this.subscriptions.set(appId, subscription);
-        if (this.socket.connected && this.needsFreshConnection) {
-            // Leave has no acknowledgement; a new transport fences late events from retired streams.
-            this.socket.disconnect();
-            void this.connect().catch(() => { }); // Connection errors are delivered through onError.
-        }
-        else if (this.socket.connected) {
-            this.join(subscription, this.generation);
-        }
-        return subscription;
-    }
-    /** Stop delivery, cancel reconnection and release all listeners. Idempotent and terminal. */
-    close() {
-        var _a, _b;
-        if (this.closed)
-            return;
-        this.closed = true;
-        ++this.authAttempt;
-        (_a = this.cancelAuth) === null || _a === void 0 ? void 0 : _a.call(this);
-        ++this.generation;
-        for (const subscription of this.subscriptions.values())
-            subscription.unsubscribe();
-        (_b = this.rejectConnect) === null || _b === void 0 ? void 0 : _b.call(this, new PlatformSocketError("client_closed"));
-        this.clearConnecting();
-        this.socket.removeAllListeners();
-        this.socket.io.removeAllListeners();
-        this.socket.disconnect();
-    }
-    join(subscription, generation) {
-        subscription.join((cursor) => {
-            if (this.socket.connected && generation === this.generation) {
-                this.socket.emit("join", roomFor(subscription.appId), cursor === undefined ? {} : { after_seq: cursor });
-            }
-        });
-    }
-    async authenticate(callback) {
-        var _a;
-        const attempt = ++this.authAttempt;
-        (_a = this.cancelAuth) === null || _a === void 0 ? void 0 : _a.call(this);
-        let timer;
-        const timeout = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error("Token timeout")), 20000);
-            this.cancelAuth = () => { clearTimeout(timer); reject(new Error("Cancelled")); };
-        });
-        try {
-            const token = await Promise.race([Promise.resolve().then(() => this.options.getToken()), timeout]);
-            if (this.closed || attempt !== this.authAttempt)
-                return;
-            if (typeof token !== "string" || !token.trim())
-                throw new Error("Missing token");
-            callback({ token });
-        }
-        catch (_b) {
-            if (this.closed || attempt !== this.authAttempt)
-                return;
-            this.socket.disconnect();
-            this.connectionError(new PlatformSocketError("token_unavailable"));
-        }
-        finally {
-            clearTimeout(timer);
-            if (attempt === this.authAttempt)
-                this.cancelAuth = undefined;
-        }
-    }
-    clearConnecting() {
-        this.connecting = undefined;
-        this.resolveConnect = undefined;
-        this.rejectConnect = undefined;
-    }
-    connectionError(error) {
-        var _a;
-        (_a = this.rejectConnect) === null || _a === void 0 ? void 0 : _a.call(this, error);
-        this.clearConnecting();
-        if (!this.closed)
-            notify(this.options.onError, error);
-    }
-    serverError(raw) {
-        var _a;
-        try {
-            const frame = object(raw);
-            const code = errorCodes.find((code) => code === frame.code);
-            if (!code)
-                throw new Error("Unknown error");
-            const appId = appFromRoom(frame.room);
-            if (appId)
-                (_a = this.subscriptions.get(appId)) === null || _a === void 0 ? void 0 : _a.fail(code);
-            else if (frame.room === null)
-                this.connectionError(new PlatformSocketError(code));
-            else
-                throw new Error("Invalid room");
-        }
-        catch (_b) {
-            this.protocolError(raw);
-        }
-    }
-    protocolError(raw) {
-        var _a, _b;
-        const frame = raw && typeof raw === "object" ? raw : {};
-        const appId = (_a = appFromRoom(frame.room)) !== null && _a !== void 0 ? _a : (typeof frame.app_id === "string" && appPattern.test(frame.app_id) ? frame.app_id : undefined);
-        if (appId)
-            (_b = this.subscriptions.get(appId)) === null || _b === void 0 ? void 0 : _b.fail("protocol_error");
-        else {
-            // Unknown routing means no app cursor can safely advance past this frame.
-            for (const subscription of [...this.subscriptions.values()])
-                subscription.fail("protocol_error");
-            this.connectionError(new PlatformSocketError("protocol_error"));
-        }
-    }
-}

package/dist/platform/client/errors.d.ts

@@ -1,11 +0,0 @@
-/** Server subscription failures and client transport/processing failures. */
-export type PlatformSocketErrorCode = "invalid_room" | "invalid_cursor" | "access_denied" | "subscription_limit" | "resync_required" | "stream_unavailable" | "connection_denied" | "connection_failed" | "token_unavailable" | "protocol_error" | "handler_failed" | "client_closed";
-/** Sanitized failure. Original token-provider, handler and server exceptions are not retained. */
-export declare class PlatformSocketError extends Error {
-    /** Stable machine-readable category. */
-    readonly code: PlatformSocketErrorCode;
-    /** Associated app, when the server identifies a valid room. */
-    readonly appId?: string;
-    /** Create a sanitized error with no credential-bearing cause or payload. */
-    constructor(code: PlatformSocketErrorCode, appId?: string);
-}

package/dist/platform/client/errors.js

@@ -1,10 +0,0 @@
-/** Sanitized failure. Original token-provider, handler and server exceptions are not retained. */
-export class PlatformSocketError extends Error {
-    /** Create a sanitized error with no credential-bearing cause or payload. */
-    constructor(code, appId) {
-        super(`Platform socket: ${code}`);
-        this.name = "PlatformSocketError";
-        this.code = code;
-        this.appId = appId;
-    }
-}

package/dist/platform/client/events.d.ts

@@ -1,159 +0,0 @@
-/** Public progress of an existing builder tool; arguments and results are withheld. */
-export interface ToolCall {
-    /** Stable tool call identifier, when included in the update. */
-    id?: string;
-    /** Tool name displayed by the builder. */
-    name?: string;
-    /** Current execution state. */
-    status?: "running" | "success" | "error" | "stopped" | "waiting_for_user_input";
-    /** Whether the tool needs a user response through the partner backend. */
-    requires_user_input?: boolean;
-    /** Existing serialized interaction category; no raw interaction payload. */
-    waiting_on?: {
-        /** Kind of response expected. */
-        kind?: "approval" | "choice" | "input" | null;
-    };
-}
-/** Public message replacement. Omitted properties are not synthesized by the SDK. */
-export interface ChatMessage {
-    /** Existing message identifier; replace a message with the same identifier. */
-    id?: string;
-    /** Public message author category. System messages are never delivered. */
-    role?: "user" | "assistant";
-    /** Generated or user-authored text. Structural filtering is not prose redaction. */
-    content?: string | null;
-    /** Attached file URLs. */
-    file_urls?: string[] | null;
-    /** Public tool progress, without arguments or results. */
-    tool_calls?: ToolCall[] | null;
-    /** Message timestamp, without author identity. */
-    metadata?: {
-        /** Existing timestamp string. */
-        created_date?: string | null;
-    } | null;
-    /** Existing checkpoint reference; mutations remain on the partner backend. */
-    checkpoint_id?: string | null;
-}
-/** Partial app update. Omitted keys mean unchanged; explicit null means clear. */
-export interface AppUpdate {
-    /** Public builder state, without error diagnostics or billing context. */
-    status?: {
-        /** Current builder state. */
-        state?: "ready" | "processing" | "error";
-        /** Existing state timestamp. */
-        last_updated_date?: string | null;
-    } | null;
-    /** Whole-message replacement by identifier, not a recursive message patch. */
-    _last_msg?: ChatMessage | null;
-    /** Conversation containing the replacement message. */
-    _last_msg_conversation_id?: string | null;
-    /** Existing branch scope, if supplied by the producer. */
-    _scope_branch_id?: string | null;
-    /** Whether to reload the app preview. */
-    sandbox_should_reload?: boolean | null;
-    /** Existing preview navigation target. */
-    navigate_preview_to?: string | null;
-    /** Existing forced preview navigation target. */
-    navigate_preview_force_to?: string | null;
-}
-/** Public queued builder request. */
-export interface QueueItem {
-    /** Stable queue item identifier. */
-    id: string;
-    /** User-authored request text. */
-    content: string;
-    /** Attached file URLs. */
-    file_urls?: string[] | null;
-    /** Existing creation timestamp. */
-    created_at: string;
-    /** Existing branch scope. */
-    branch_id?: string | null;
-}
-/** Full public queue snapshot, replacing the previous queue. */
-export interface QueueUpdate {
-    /** App owning this queue. */
-    app_id: string;
-    /** Existing branch scope. */
-    branch_id?: string | null;
-    /** Current pending items. */
-    items: QueueItem[];
-    /** Whether queue processing is paused. */
-    is_paused: boolean;
-    /** Identifier of the item just processed, when supplied. */
-    processed_item_id?: string | null;
-}
-/** Public tool task progress. */
-export interface TaskUpdate {
-    /** Existing task lifecycle event. */
-    event_type: "task_started" | "task_progress" | "task_completed" | "task_failed" | "task_cancelled";
-    /** Associated tool call. */
-    tool_call_id?: string | null;
-    /** Associated chat message. */
-    message_id?: string | null;
-    /** Existing branch scope. */
-    branch_id?: string | null;
-    /** Numeric progress only; diagnostic/free-text messages are withheld. */
-    progress?: {
-        /** Completed work units. */
-        current?: number | null;
-        /** Total work units, when known. */
-        total?: number | null;
-        /** Producer-supplied percentage. */
-        percentage?: number | null;
-    } | null;
-}
-/** Placeholder resolution or image-generation completion. */
-export interface ImageReady {
-    /** Placeholder being resolved. */
-    placeholder_url: string;
-    /** Existing generation state. */
-    status: "pending" | "completed" | "failed";
-    /** Resolved image URL, or null when unavailable. */
-    image_url?: string | null;
-}
-/** Invalidation notice; fetch current state through the partner backend. */
-export interface Directive {
-    /** Canonical app room. */
-    room: string;
-    /** Public invalidation category. */
-    type: "conversation_changed" | "app_files_changed";
-    /** Existing branch scope. */
-    branch_id?: string | null;
-}
-/** Mapping of wire event names to decoded public payloads. */
-export interface PlatformEventMap {
-    /** Partial builder/app update. */
-    update_model: AppUpdate;
-    /** Conversation or file invalidation. */
-    directive: Directive;
-    /** Full queue snapshot. */
-    queue_update: QueueUpdate;
-    /** Numeric tool progress. */
-    task_update: TaskUpdate;
-    /** Image placeholder resolution. */
-    image_ready: ImageReady;
-}
-/** Ordered delivery with decoded data and the original event name and cursor. */
-export type PlatformEvent = {
-    [K in keyof PlatformEventMap]: {
-        /** Original socket event name; narrows the payload type. */
-        type: K;
-        /** Authorized app receiving this event. */
-        appId: string;
-        /** Opaque replay cursor. Never parse, compare or increment it. */
-        seq: string;
-        /** Decoded payload; existing field names and omission/null semantics are retained. */
-        data: PlatformEventMap[K];
-    };
-}[keyof PlatformEventMap];
-/** Server replay boundary, delivered after all retained events through that boundary. */
-export interface Joined {
-    /** Canonical app room. */
-    room: string;
-    /** Opaque boundary cursor; not an initial app snapshot. */
-    seq: string;
-    /** Server retention limit (currently 2,000 events per app). */
-    max_entries: number;
-    /** Server inactivity expiry (currently 3,600 seconds). */
-    inactivity_expiry_seconds: number;
-}

package/dist/platform/client/events.js

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

package/dist/platform/client/index.d.ts

@@ -1,6 +0,0 @@
-/** Read-only browser platform subscriptions, separate from the runtime and server SDKs. */
-export { Base44PlatformClient } from "./client.js";
-export { PlatformSocketError } from "./errors.js";
-export type { PlatformSocketErrorCode } from "./errors.js";
-export type { PlatformClientOptions, PlatformSubscription, SubscriptionOptions } from "./types.js";
-export type { AppUpdate, ChatMessage, ToolCall, QueueItem, QueueUpdate, TaskUpdate, ImageReady, Directive, PlatformEventMap, PlatformEvent, Joined } from "./events.js";

package/dist/platform/client/index.js

@@ -1,3 +0,0 @@
-/** Read-only browser platform subscriptions, separate from the runtime and server SDKs. */
-export { Base44PlatformClient } from "./client.js";
-export { PlatformSocketError } from "./errors.js";

package/dist/platform/client/protocol.d.ts

@@ -1,11 +0,0 @@
-import type { Joined, PlatformEvent, PlatformEventMap } from "./events.js";
-export declare const eventNames: readonly ["update_model", "directive", "queue_update", "task_update", "image_ready"];
-export declare const errorCodes: readonly ["invalid_room", "invalid_cursor", "access_denied", "subscription_limit", "resync_required", "stream_unavailable"];
-export declare const appPattern: RegExp;
-export declare const roomFor: (appId: string) => string;
-export declare function object(value: unknown): Record<string, unknown>;
-export declare function string(value: unknown): string;
-export declare function appFromRoom(value: unknown): string | undefined;
-export declare function eventApp(type: keyof PlatformEventMap, raw: unknown): string | undefined;
-export declare function decode(type: keyof PlatformEventMap, appId: string, raw: unknown): PlatformEvent;
-export declare function decodeJoined(raw: unknown): Joined;

package/dist/platform/client/protocol.js

@@ -1,39 +0,0 @@
-export const eventNames = ["update_model", "directive", "queue_update", "task_update", "image_ready"];
-export const errorCodes = ["invalid_room", "invalid_cursor", "access_denied", "subscription_limit", "resync_required", "stream_unavailable"];
-export const appPattern = /^[a-f0-9]{24}$/;
-export const roomFor = (appId) => `/apps/${appId}`;
-export function object(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new Error("Invalid frame");
-    return value;
-}
-export function string(value) {
-    if (typeof value !== "string" || !value)
-        throw new Error("Invalid string");
-    return value;
-}
-export function appFromRoom(value) {
-    return typeof value === "string" && /^\/apps\/[a-f0-9]{24}$/.test(value) ? value.slice(6) : undefined;
-}
-export function eventApp(type, raw) {
-    const frame = object(raw);
-    return type === "queue_update"
-        ? typeof frame.app_id === "string" && appPattern.test(frame.app_id) ? frame.app_id : undefined
-        : appFromRoom(frame.room);
-}
-export function decode(type, appId, raw) {
-    const frame = object(raw);
-    const seq = string(frame.seq);
-    const wrapped = type === "update_model" || type === "task_update" || type === "image_ready";
-    const { seq: _, ...flat } = frame;
-    const data = wrapped ? object(JSON.parse(string(frame.data))) : flat;
-    // Payload schemas are owned by the service; only decode/validate the transport envelope here.
-    return { type, appId, seq, data };
-}
-export function decodeJoined(raw) {
-    const frame = object(raw);
-    if (!appFromRoom(frame.room) || !Number.isInteger(frame.max_entries) || !Number.isInteger(frame.inactivity_expiry_seconds))
-        throw new Error("Invalid boundary");
-    string(frame.seq);
-    return frame;
-}

package/dist/platform/client/subscription.d.ts

@@ -1,23 +0,0 @@
-import type { Joined, PlatformEvent } from "./events.js";
-import { PlatformSocketError, type PlatformSocketErrorCode } from "./errors.js";
-import type { PlatformSubscription, SubscriptionOptions } from "./types.js";
-/** @internal */
-export declare function notify(callback: (error: PlatformSocketError) => void, error: PlatformSocketError): void;
-/** @internal */
-export declare class Subscription implements PlatformSubscription {
-    readonly appId: string;
-    private options;
-    private remove;
-    cursor: string | undefined;
-    active: boolean;
-    private ready;
-    private pending;
-    private tail;
-    constructor(appId: string, options: SubscriptionOptions, remove: () => void);
-    enqueue(work: () => void | Promise<void>): void;
-    join(send: (cursor?: string) => void): void;
-    event(event: PlatformEvent): void;
-    joined(joined: Joined): void;
-    fail(code: PlatformSocketErrorCode): void;
-    unsubscribe(): void;
-}

package/dist/platform/client/subscription.js

@@ -1,69 +0,0 @@
-import { PlatformSocketError } from "./errors.js";
-/** @internal */
-export function notify(callback, error) {
-    try {
-        callback(error);
-    }
-    catch ( /* An error observer cannot interrupt other app subscriptions. */_a) { /* An error observer cannot interrupt other app subscriptions. */ }
-}
-/** @internal */
-export class Subscription {
-    constructor(appId, options, remove) {
-        this.appId = appId;
-        this.options = options;
-        this.remove = remove;
-        this.active = true;
-        this.ready = false;
-        this.pending = 0;
-        this.tail = Promise.resolve();
-        this.cursor = options.afterSeq;
-    }
-    enqueue(work) {
-        if (!this.active)
-            return;
-        if (this.pending >= 1000) {
-            this.fail("resync_required");
-            return;
-        }
-        this.pending++;
-        this.tail = this.tail.then(async () => {
-            if (this.active)
-                await work();
-        }).catch(() => this.fail("handler_failed")).finally(() => { this.pending--; });
-    }
-    join(send) {
-        this.enqueue(() => { this.ready = false; send(this.cursor); });
-    }
-    event(event) {
-        this.enqueue(async () => {
-            // A fresh subscription starts at joined, not at any old in-flight room events.
-            if ((!this.ready && this.cursor === undefined) || event.seq === this.cursor)
-                return;
-            await this.options.onEvent(event);
-            if (this.active)
-                this.cursor = event.seq;
-        });
-    }
-    joined(joined) {
-        this.enqueue(async () => {
-            var _a, _b;
-            await ((_b = (_a = this.options).onJoined) === null || _b === void 0 ? void 0 : _b.call(_a, joined));
-            if (this.active) {
-                this.cursor = joined.seq;
-                this.ready = true;
-            }
-        });
-    }
-    fail(code) {
-        if (!this.active)
-            return;
-        this.unsubscribe();
-        notify(this.options.onError, new PlatformSocketError(code, this.appId));
-    }
-    unsubscribe() {
-        if (!this.active)
-            return;
-        this.active = false;
-        this.remove();
-    }
-}

package/dist/platform/client/types.d.ts

@@ -1,33 +0,0 @@
-import type { Joined, PlatformEvent } from "./events.js";
-import type { PlatformSocketError } from "./errors.js";
-/** Configuration for the browser platform connection. Never supply an API key. */
-export interface PlatformClientOptions {
-    /** Origin of the platform service, e.g. https://base44.app. No path/query/credentials. */
-    serverUrl: string;
-    /** Fetch a browser credential from your backend. Called for every connection attempt. */
-    getToken: () => string | Promise<string>;
-    /** Connection-level error notification. Errors never include tokens or server exception text. */
-    onError: (error: PlatformSocketError) => void;
-}
-/** One app subscription; at most eight may be active per client. */
-export interface SubscriptionOptions {
-    /** Last successfully applied cursor for this app; omit for a fresh live boundary. */
-    afterSeq?: string;
-    /** Apply each event. Delivery is serial per app; rejection pauses this subscription. */
-    onEvent: (event: PlatformEvent) => void | Promise<void>;
-    /** Handle subscription errors. Reconcile on resync_required; never silently reset a cursor. */
-    onError: (error: PlatformSocketError) => void;
-    /** Optional replay-complete notification, awaited before advancing to the boundary cursor. */
-    onJoined?: (joined: Joined) => void | Promise<void>;
-}
-/** Subscription lifetime and last successfully applied cursor. */
-export interface PlatformSubscription {
-    /** App identifier. */
-    readonly appId: string;
-    /** Last applied event/boundary cursor; persist alongside the state it describes. */
-    readonly cursor: string | undefined;
-    /** True while subscribed; false after an error or explicit unsubscribe. */
-    readonly active: boolean;
-    /** Stop this app's delivery and release its subscription slot. Idempotent. */
-    unsubscribe(): void;
-}

package/dist/platform/client/types.js

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