@arcote.tech/arc 0.7.15 → 0.7.17

package/dist/adapters/event-publisher.d.ts

@@ -14,7 +14,7 @@
 import type { ArcEventAny } from "../context-element/event";
 import type { ArcEventInstance } from "../context-element/event/instance";
 import type { ArcViewAny } from "../context-element/view/view";
-import type { CommittedChange, DataStorage } from "../data-storage";
+import type { DataStorage } from "../data-storage";
 /** Shared table names for all events */
 export declare const EVENT_TABLES: {
     readonly events: "events";
@@ -99,19 +99,12 @@ export declare class LocalEventPublisher implements EventPublisher {
     private views;
     private syncCallback?;
     private subscribers;
-    private viewChangesCallbacks;
     constructor(dataStorage: DataStorage);
     /**
      * Set a callback to be called after each event is published
      * Used for syncing events to the host
      */
     onPublish(callback: (event: ArcEventInstance<ArcEventAny>) => void): void;
-    /**
-     * Register a callback fired after each publish commit with the committed
-     * VIEW store changes (old/new rows). Used by the host to broadcast
-     * incremental view deltas to subscribed streaming clients.
-     */
-    onViewChanges(callback: (changes: CommittedChange[]) => void): () => void;
     /**
      * Register views that should be updated when events are published
      */

package/dist/adapters/event-wire.d.ts

@@ -24,16 +24,19 @@ export interface ReceivedEvent {
     clientId: string;
     authContext: EventAuthContext | null;
 }
-import type { ListenerEvent } from "../data-storage/data-storage.abstract";
+import type { ContextDescriptor } from "../model/context-accessor";
+import type { QueryResultChange } from "../model/live-query/diff";
 type EventWireState = "disconnected" | "connecting" | "connected";
 /**
- * Callbacks for a view replica subscription. The server answers
- * `subscribe-view` with a full `view-snapshot`, then pushes incremental
- * `view-changes` deltas (already filtered by the scope's token).
+ * Callbacks for a live query subscription. The server answers
+ * `subscribe-query` with a full `query-snapshot` (the query's result),
+ * then pushes positional `query-changes` deltas computed by the server-side
+ * LiveQuery (re-execute + diff). Non-list results always arrive as
+ * snapshots.
  */
-export interface ViewSubscriptionCallbacks {
-    onSnapshot: (items: any[]) => void;
-    onChanges: (changes: ListenerEvent<any>[]) => void;
+export interface QuerySubscriptionCallbacks {
+    onSnapshot: (result: any) => void;
+    onChanges: (changes: QueryResultChange[]) => void;
 }
 export declare class EventWire {
     private readonly baseUrl;
@@ -47,13 +50,15 @@ export declare class EventWire {
     private onSyncedCallback?;
     private reconnectTimeout?;
     private syncRequested;
-    /** Active view subscriptions keyed by `${scope}:${element}`. Re-sent in
-     *  full on every (re)connect — the server drops its registry on
-     *  disconnect, and a fresh snapshot follows each re-subscribe. */
-    private viewSubscriptions;
+    /** Active query subscriptions keyed by subscriptionId. Re-sent in full
+     *  on every (re)connect — the server drops its registry on disconnect,
+     *  and a fresh snapshot follows each re-subscribe. */
+    private querySubscriptions;
+    private querySubCounter;
     /** When false (streaming mode), the client neither requests the event
-     *  log (`request-sync`) nor consumes domain events — view replicas are
-     *  the only data channel. Local mode keeps full event sync. */
+     *  log (`request-sync`) nor consumes domain events — live query
+     *  subscriptions are the only data channel. Local mode keeps full
+     *  event sync. */
     private readonly enableEventSync;
     constructor(baseUrl: string, options?: {
         enableEventSync?: boolean;
@@ -97,16 +102,16 @@ export declare class EventWire {
      */
     onSynced(callback: (localIds: string[]) => void): void;
     /**
-     * Subscribe to a view replica. The server responds with a full
-     * `view-snapshot` of the token's slice, then pushes `view-changes`
-     * deltas. One subscription per `${scope}:${element}` — callers dedupe
-     * (StreamingQueryCache.registerStream).
+     * Subscribe to a live query. The server executes the descriptor with
+     * tracking, responds with a full `query-snapshot`, then pushes positional
+     * `query-changes` deltas whenever the result changes. Callers dedupe
+     * identical descriptors (StreamingQueryCache).
      */
-    subscribeView(element: string, scope: string, callbacks: ViewSubscriptionCallbacks): void;
+    subscribeQuery(descriptor: ContextDescriptor, scope: string, callbacks: QuerySubscriptionCallbacks): string;
     /**
-     * Unsubscribe from a view replica.
+     * Unsubscribe from a live query.
      */
-    unsubscribeView(element: string, scope: string): void;
+    unsubscribeQuery(subscriptionId: string): void;
     /**
      * Get current connection state
      */
@@ -120,11 +125,12 @@ export declare class EventWire {
     private requestSync;
     private flushPendingEvents;
     /**
-     * (Re)send every active view subscription. Called on each (re)connect —
+     * (Re)send every active query subscription. Called on each (re)connect —
      * covers both subscriptions made while offline and re-establishing the
      * server-side registry after a reconnect (server cleans it on disconnect).
+     * Each re-subscribe yields a fresh snapshot.
      */
-    private sendAllViewSubscriptions;
+    private sendAllQuerySubscriptions;
     private scheduleReconnect;
 }
 export {};

package/dist/adapters/index.d.ts

@@ -10,9 +10,11 @@
  */
 export { AuthAdapter } from "./auth-adapter";
 export type { DecodedToken } from "./auth-adapter";
+export { awaitModuleSync, hasModuleSyncProvider, registerModuleSyncProvider, triggerModuleSync, } from "./module-sync-coordinator";
+export type { ModuleSyncProvider } from "./module-sync-coordinator";
 export { CommandWire } from "./command-wire";
 export { EventWire } from "./event-wire";
-export type { ReceivedEvent, SyncableEvent, ViewSubscriptionCallbacks, } from "./event-wire";
+export type { QuerySubscriptionCallbacks, ReceivedEvent, SyncableEvent, } from "./event-wire";
 export { QueryWire } from "./query-wire";
 export { Wire } from "./wire";
 export type { WireAuth } from "./wire";

package/dist/adapters/module-sync-coordinator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Module-sync coordinator — neutral seam letting token-setters (core/react)
+ * await the platform module loader WITHOUT core/react depending on platform.
+ *
+ * Token-gated code-splitting: setting a scope token must dynamically import
+ * that token's module chunks before routes inside them exist. The loader
+ * lives in the platform layer; setToken lives in core/react. This singleton
+ * is the bridge: platform's useModuleLoader registers a provider (runs
+ * syncModules), and setToken triggers a sync + returns a promise that
+ * resolves when the LATEST sync finishes.
+ *
+ * With no provider registered (server, SSR, tests, app-without-platform)
+ * every call resolves immediately — preserving the historical synchronous
+ * semantics. It NEVER rejects: a hung/failed sync resolves after a bounded
+ * timeout so navigation always proceeds.
+ */
+export type ModuleSyncProvider = (scope?: string) => Promise<void>;
+/**
+ * Register the function that performs a module sync. Returns an unregister fn.
+ * Last registration wins (only one platform loader is ever mounted).
+ */
+export declare function registerModuleSyncProvider(fn: ModuleSyncProvider): () => void;
+export declare function hasModuleSyncProvider(): boolean;
+/**
+ * Trigger a sync through the registered provider; resolve when it finishes
+ * (or after `timeoutMs`). Coalesces concurrent calls — the published
+ * `latestSync` tracks the newest invocation.
+ *
+ * - No provider → resolves immediately (sync semantics preserved).
+ * - Provider hangs → resolves (never rejects) after `timeoutMs` + a warning.
+ * - Provider throws → resolves (never rejects) + a warning; the loader
+ *   surfaces its own error state. setToken must not throw on module-load fail.
+ */
+export declare function triggerModuleSync(scope?: string, timeoutMs?: number): Promise<void>;
+/**
+ * Await the most recent sync without triggering a new one. Resolves
+ * immediately when nothing is in flight.
+ */
+export declare function awaitModuleSync(): Promise<void>;
+//# sourceMappingURL=module-sync-coordinator.d.ts.map

package/dist/adapters/module-sync-coordinator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=module-sync-coordinator.test.d.ts.map

package/dist/adapters/query-wire.d.ts

@@ -5,8 +5,8 @@
  * - One-shot queries via HTTP POST
  * - Per-request auth via scope + token
  *
- * Live updates go through EventWire view subscriptions
- * (view-snapshot + view-changes), not through this adapter.
+ * Live updates go through EventWire query subscriptions
+ * (query-snapshot + query-changes), not through this adapter.
  */
 import { Wire, type WireAuth } from "./wire";
 export declare class QueryWire extends Wire {

package/dist/context-element/aggregate/aggregate-element.d.ts

@@ -196,16 +196,6 @@ export declare class ArcAggregateElement<Name extends string = string, Id extend
     get cronMethods(): AggregateCronMethodEntry[];
     queryContext(adapters: ModelAdapters): AggregateQueryContext<QueryMethods>;
     private buildPrivateQuery;
-    /**
-     * Resolve this aggregate's protection for the current auth context.
-     * Public entry point for the host's view-subscription handler — used to
-     * compute the subscriber's restrictions once at subscribe time (snapshot
-     * filtering + per-delta filtering).
-     */
-    getRestrictionsFor(adapters: ModelAdapters): {
-        restrictions: Record<string, unknown> | null;
-        denied: boolean;
-    };
     private isScopeDenied;
     private getAuth;
     private getScopeRestrictions;

package/dist/context-element/view/view.d.ts

@@ -104,16 +104,6 @@ export declare class ArcView<const Data extends ArcViewData> extends ArcContextE
      * @returns Context object with find/findOne methods
      */
     queryContext(adapters: any): ArcViewQueryContext<Data["id"], Data["schema"]>;
-    /**
-     * Resolve this view's protection for the current auth context.
-     * Public entry point for the host's view-subscription handler — used to
-     * compute the subscriber's restrictions once at subscribe time (snapshot
-     * filtering + per-delta filtering).
-     */
-    getRestrictionsFor(adapters: any): {
-        restrictions: Record<string, unknown> | null;
-        denied: boolean;
-    };
     private resolveProtection;
     /**
      * Get event handlers for this view

package/dist/data-storage/data-storage-master.d.ts

@@ -1,5 +1,5 @@
 import { ForkedDataStorage } from "./data-storage-forked";
-import { DataStorage, type CommittedChange, type DataStorageChanges } from "./data-storage.abstract";
+import { DataStorage, type DataStorageChanges } from "./data-storage.abstract";
 import type { DatabaseAdapter, ReadTransaction, ReadWriteTransaction } from "./database-adapter";
 import type { StoreState } from "./store-state.abstract";
 export declare class MasterDataStorage extends DataStorage {
@@ -22,9 +22,7 @@ export declare class MasterDataStorage extends DataStorage {
             _id: string;
         } | null;
     }[][]>;
-    commitChanges(changes: DataStorageChanges[], options?: {
-        captureRowsFor?: Set<string>;
-    }): Promise<CommittedChange[]>;
+    commitChanges(changes: DataStorageChanges[]): Promise<void>;
     fork(): ForkedDataStorage;
     /**
      * Destroy the data storage - clears all stores and destroys the database

package/dist/data-storage/data-storage-observable.d.ts

@@ -1,5 +1,5 @@
 import type { ForkedDataStorage } from "./data-storage-forked";
-import type { CommittedChange, DataStorage, DataStorageChanges, ListenerEvent, QueryListenerCallback } from "./data-storage.abstract";
+import type { DataStorage, DataStorageChanges, ListenerEvent, QueryListenerCallback } from "./data-storage.abstract";
 import type { ReadTransaction, ReadWriteTransaction } from "./database-adapter";
 import type { FindOptions } from "./find-options";
 import type { StoreState } from "./store-state.abstract";
@@ -25,9 +25,7 @@ export declare class ObservableDataStorage {
     fork(): ForkedDataStorage;
     getReadTransaction(): Promise<ReadTransaction>;
     getReadWriteTransaction(): Promise<ReadWriteTransaction>;
-    commitChanges(changes: DataStorageChanges[], options?: {
-        captureRowsFor?: Set<string>;
-    }): Promise<CommittedChange[]>;
+    commitChanges(changes: DataStorageChanges[]): Promise<void>;
     /**
      * Register a tracked query
      */

package/dist/data-storage/data-storage-observable.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-storage-observable.test.d.ts.map

package/dist/data-storage/data-storage.abstract.d.ts

@@ -9,21 +9,8 @@ export declare abstract class DataStorage {
     abstract fork(): ForkedDataStorage;
     abstract getReadTransaction(): Promise<ReadTransaction>;
     abstract getReadWriteTransaction(): Promise<ReadWriteTransaction>;
-    commitChanges(changes: DataStorageChanges[], _options?: {
-        captureRowsFor?: Set<string>;
-    }): Promise<CommittedChange[]>;
+    commitChanges(changes: DataStorageChanges[]): Promise<void>;
 }
-/**
- * A change applied and committed to a store, with the row state before and
- * after the write (store/DB form). Returned by `commitChanges` for stores
- * requested via `captureRowsFor` — consumed by view-change broadcasting.
- */
-export type CommittedChange = {
-    store: string;
-    id: string;
-    oldRow: any | null;
-    newRow: any | null;
-};
 export type StoreStateChange<Item> = {
     type: "set";
     data: Item;

package/dist/data-storage/store-state-master.d.ts

@@ -13,20 +13,10 @@ export declare class MasterStoreState<Item extends {
      * the same aggregate id) and must not shadow each other.
      */
     private readExisting;
-    applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>, transactionCache?: Map<string, Item>, options?: {
-        captureRows?: boolean;
-    }): Promise<{
+    applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>, transactionCache?: Map<string, Item>): Promise<{
         from: Item | null;
         to: Item | null;
         event: ListenerEvent<Item>;
-        /**
-         * Rows in store form (as written to the DB) for change broadcasting:
-         * state before the write and after. Captured for modify/mutate always
-         * (existing is read for the merge anyway); for set/delete only when
-         * `options.captureRows` — avoids extra PK lookups on event tables.
-         */
-        oldRow: Item | null;
-        newRow: Item | null;
     }>;
     applyChange(change: StoreStateChange<Item>): Promise<{
         from: Item | null;