@syncular/client 0.0.5-42 → 0.0.6-101

package/src/pull-engine.test.ts

@@ -1,14 +1,15 @@
 import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
 import { gzipSync } from 'node:zlib';
 import {
+  createDatabase,
   encodeSnapshotRows,
   type SyncPullResponse,
   type SyncTransport,
 } from '@syncular/core';
 import { type Kysely, sql } from 'kysely';
-import { createBunSqliteDb } from '../../dialect-bun-sqlite/src';
+import { createBunSqliteDialect } from '../../dialect-bun-sqlite/src';
+import type { ClientHandlerCollection } from './handlers/collection';
 import { createClientHandler } from './handlers/create-handler';
-import { ClientTableRegistry } from './handlers/registry';
 import { ensureClientSyncSchema } from './migrate';
 import { applyPullResponse, buildPullRequest } from './pull-engine';
 import type { SyncClientDb } from './schema';
@@ -40,7 +41,10 @@ describe('applyPullResponse chunk streaming', () => {
   let db: Kysely<TestDb>;
 
   beforeEach(async () => {
-    db = createBunSqliteDb<TestDb>({ path: ':memory:' });
+    db = createDatabase<TestDb>({
+      dialect: createBunSqliteDialect({ path: ':memory:' }),
+      family: 'sqlite',
+    });
     await ensureClientSyncSchema(db);
     await db.schema
       .createTable('items')
@@ -75,12 +79,12 @@ describe('applyPullResponse chunk streaming', () => {
       },
     };
 
-    const handlers = new ClientTableRegistry<TestDb>().register(
+    const handlers: ClientHandlerCollection<TestDb> = [
       createClientHandler({
         table: 'items',
         scopes: ['items:{id}'],
-      })
-    );
+      }),
+    ];
 
     const options = {
       clientId: 'client-1',
@@ -144,4 +148,145 @@ describe('applyPullResponse chunk streaming', () => {
     expect(Number(countResult.rows[0]?.count ?? 0)).toBe(rows.length);
     expect(streamFetchCount).toBe(1);
   });
+
+  it('rolls back partial chunked bootstrap when a later chunk fails', async () => {
+    const firstRows = Array.from({ length: 1500 }, (_, index) => ({
+      id: `${index + 1}`,
+      name: `Item ${index + 1}`,
+    }));
+    const secondRows = Array.from({ length: 1500 }, (_, index) => ({
+      id: `${index + 1501}`,
+      name: `Item ${index + 1501}`,
+    }));
+
+    const firstChunk = new Uint8Array(gzipSync(encodeSnapshotRows(firstRows)));
+    const secondChunk = new Uint8Array(
+      gzipSync(encodeSnapshotRows(secondRows))
+    );
+
+    let failSecondChunk = true;
+    const transport: SyncTransport = {
+      async sync() {
+        return {};
+      },
+      async fetchSnapshotChunk() {
+        throw new Error('fetchSnapshotChunk should not be used');
+      },
+      async fetchSnapshotChunkStream({ chunkId }) {
+        if (chunkId === 'chunk-2' && failSecondChunk) {
+          throw new Error('chunk-2 missing');
+        }
+        if (chunkId === 'chunk-1') {
+          return createStreamFromBytes(firstChunk, 317);
+        }
+        if (chunkId === 'chunk-2') {
+          return createStreamFromBytes(secondChunk, 503);
+        }
+        throw new Error(`Unexpected chunk id: ${chunkId}`);
+      },
+    };
+
+    const handlers: ClientHandlerCollection<TestDb> = [
+      createClientHandler({
+        table: 'items',
+        scopes: ['items:{id}'],
+      }),
+    ];
+
+    const options = {
+      clientId: 'client-1',
+      subscriptions: [
+        {
+          id: 'items-sub',
+          table: 'items',
+          scopes: {},
+        },
+      ],
+      stateId: 'default',
+    };
+
+    const response: SyncPullResponse = {
+      ok: true,
+      subscriptions: [
+        {
+          id: 'items-sub',
+          status: 'active',
+          scopes: {},
+          bootstrap: true,
+          bootstrapState: null,
+          nextCursor: 12,
+          commits: [],
+          snapshots: [
+            {
+              table: 'items',
+              rows: [],
+              chunks: [
+                {
+                  id: 'chunk-1',
+                  byteLength: firstChunk.length,
+                  sha256: '',
+                  encoding: 'json-row-frame-v1',
+                  compression: 'gzip',
+                },
+                {
+                  id: 'chunk-2',
+                  byteLength: secondChunk.length,
+                  sha256: '',
+                  encoding: 'json-row-frame-v1',
+                  compression: 'gzip',
+                },
+              ],
+              isFirstPage: true,
+              isLastPage: true,
+            },
+          ],
+        },
+      ],
+    };
+
+    const firstPullState = await buildPullRequest(db, options);
+    await expect(
+      applyPullResponse(
+        db,
+        transport,
+        handlers,
+        options,
+        firstPullState,
+        response
+      )
+    ).rejects.toThrow('chunk-2 missing');
+
+    const countAfterFailure = await sql<{ count: number }>`
+      select count(*) as count
+      from ${sql.table('items')}
+    `.execute(db);
+    expect(Number(countAfterFailure.rows[0]?.count ?? 0)).toBe(0);
+
+    const stateAfterFailure = await db
+      .selectFrom('sync_subscription_state')
+      .select(({ fn }) => fn.countAll().as('total'))
+      .where('state_id', '=', 'default')
+      .where('subscription_id', '=', 'items-sub')
+      .executeTakeFirst();
+    expect(Number(stateAfterFailure?.total ?? 0)).toBe(0);
+
+    failSecondChunk = false;
+    const retryPullState = await buildPullRequest(db, options);
+    await applyPullResponse(
+      db,
+      transport,
+      handlers,
+      options,
+      retryPullState,
+      response
+    );
+
+    const countAfterRetry = await sql<{ count: number }>`
+      select count(*) as count
+      from ${sql.table('items')}
+    `.execute(db);
+    expect(Number(countAfterRetry.rows[0]?.count ?? 0)).toBe(
+      firstRows.length + secondRows.length
+    );
+  });
 });

package/src/pull-engine.ts

@@ -6,13 +6,17 @@ import type {
   SyncBootstrapState,
   SyncPullRequest,
   SyncPullResponse,
+  SyncPullSubscriptionResponse,
   SyncSnapshot,
   SyncSubscriptionRequest,
   SyncTransport,
 } from '@syncular/core';
 import { decodeSnapshotRows } from '@syncular/core';
 import { type Kysely, sql, type Transaction } from 'kysely';
-import type { ClientTableRegistry } from './handlers/registry';
+import {
+  type ClientHandlerCollection,
+  getClientHandlerOrThrow,
+} from './handlers/collection';
 import type { ClientTableHandler } from './handlers/types';
 import type {
   SyncClientPlugin,
@@ -513,6 +517,13 @@ export interface SyncPullOnceOptions {
   sha256?: (bytes: Uint8Array) => Promise<string>;
 }
 
+export interface SyncPullRequestState {
+  request: SyncPullRequest;
+  existing: SyncSubscriptionStateTable[];
+  existingById: Map<string, SyncSubscriptionStateTable>;
+  stateId: string;
+}
+
 /**
  * Build a pull request from subscription state. Exported for use
  * by the combined sync path in sync-loop.ts.
@@ -520,12 +531,7 @@ export interface SyncPullOnceOptions {
 export async function buildPullRequest<DB extends SyncClientDb>(
   db: Kysely<DB>,
   options: SyncPullOnceOptions
-): Promise<{
-  request: SyncPullRequest;
-  existing: SyncSubscriptionStateTable[];
-  existingById: Map<string, SyncSubscriptionStateTable>;
-  stateId: string;
-}> {
+): Promise<SyncPullRequestState> {
   const stateId = options.stateId ?? 'default';
 
   const existingResult = await sql<SyncSubscriptionStateTable>`
@@ -566,6 +572,70 @@ export async function buildPullRequest<DB extends SyncClientDb>(
   return { request, existing, existingById, stateId };
 }
 
+export function createFollowupPullState(
+  pullState: SyncPullRequestState,
+  response: SyncPullResponse
+): SyncPullRequestState {
+  const responseById = new Map<string, SyncPullSubscriptionResponse>();
+  for (const sub of response.subscriptions ?? []) {
+    responseById.set(sub.id, sub);
+  }
+
+  const now = Date.now();
+  const nextExisting: SyncSubscriptionStateTable[] = [];
+  const nextExistingById = new Map<string, SyncSubscriptionStateTable>();
+
+  for (const sub of pullState.request.subscriptions ?? []) {
+    const res = responseById.get(sub.id);
+    if (res?.status === 'revoked') {
+      continue;
+    }
+
+    const nextCursor = res ? Math.max(-1, res.nextCursor) : (sub.cursor ?? -1);
+    const nextBootstrapState = res
+      ? res.bootstrap
+        ? (res.bootstrapState ?? null)
+        : null
+      : (sub.bootstrapState ?? null);
+    const prev = pullState.existingById.get(sub.id);
+    const nextRow: SyncSubscriptionStateTable = {
+      state_id: pullState.stateId,
+      subscription_id: sub.id,
+      table: sub.table,
+      scopes_json: serializeJsonCached(sub.scopes ?? {}),
+      params_json: serializeJsonCached(sub.params ?? {}),
+      cursor: nextCursor,
+      bootstrap_state_json: nextBootstrapState
+        ? serializeJsonCached(nextBootstrapState)
+        : null,
+      status: 'active',
+      created_at: prev?.created_at ?? now,
+      updated_at: now,
+    };
+    nextExisting.push(nextRow);
+    nextExistingById.set(nextRow.subscription_id, nextRow);
+  }
+
+  const nextRequest: SyncPullRequest = {
+    ...pullState.request,
+    subscriptions: (pullState.request.subscriptions ?? []).map((sub) => {
+      const row = nextExistingById.get(sub.id);
+      return {
+        ...sub,
+        cursor: Math.max(-1, row?.cursor ?? -1),
+        bootstrapState: parseBootstrapState(row?.bootstrap_state_json),
+      };
+    }),
+  };
+
+  return {
+    request: nextRequest,
+    existing: nextExisting,
+    existingById: nextExistingById,
+    stateId: pullState.stateId,
+  };
+}
+
 /**
  * Apply a pull response (run plugins + write to local DB).
  * Exported for use by the combined sync path in sync-loop.ts.
@@ -573,14 +643,9 @@ export async function buildPullRequest<DB extends SyncClientDb>(
 export async function applyPullResponse<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
+  handlers: ClientHandlerCollection<DB>,
   options: SyncPullOnceOptions,
-  pullState: {
-    request: SyncPullRequest;
-    existing: SyncSubscriptionStateTable[];
-    existingById: Map<string, SyncSubscriptionStateTable>;
-    stateId: string;
-  },
+  pullState: SyncPullRequestState,
   rawResponse: SyncPullResponse
 ): Promise<SyncPullResponse> {
   const { request, existing, existingById, stateId } = pullState;
@@ -620,7 +685,10 @@ export async function applyPullResponse<DB extends SyncClientDb>(
               ? JSON.parse(row.scopes_json)
               : row.scopes_json
             : {};
-          await handlers.getOrThrow(row.table).clearAll({ trx, scopes });
+          await getClientHandlerOrThrow(handlers, row.table).clearAll({
+            trx,
+            scopes,
+          });
         } catch {
           // ignore missing table handler
         }
@@ -649,7 +717,10 @@ export async function applyPullResponse<DB extends SyncClientDb>(
                 ? JSON.parse(prev.scopes_json)
                 : prev.scopes_json
               : {};
-            await handlers.getOrThrow(prev.table).clearAll({ trx, scopes });
+            await getClientHandlerOrThrow(handlers, prev.table).clearAll({
+              trx,
+              scopes,
+            });
           } catch {
             // ignore missing handler
           }
@@ -666,7 +737,7 @@ export async function applyPullResponse<DB extends SyncClientDb>(
       // Apply snapshots (bootstrap mode)
       if (sub.bootstrap) {
         for (const snapshot of sub.snapshots ?? []) {
-          const handler = handlers.getOrThrow(snapshot.table);
+          const handler = getClientHandlerOrThrow(handlers, snapshot.table);
           const hasChunkRefs =
             Array.isArray(snapshot.chunks) && snapshot.chunks.length > 0;
 
@@ -698,7 +769,7 @@ export async function applyPullResponse<DB extends SyncClientDb>(
         // Apply incremental changes
         for (const commit of sub.commits) {
           for (const change of commit.changes) {
-            const handler = handlers.getOrThrow(change.table);
+            const handler = getClientHandlerOrThrow(handlers, change.table);
             await handler.applyChange({ trx }, change);
           }
         }
@@ -763,10 +834,11 @@ export async function applyPullResponse<DB extends SyncClientDb>(
 export async function syncPullOnce<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
-  options: SyncPullOnceOptions
+  handlers: ClientHandlerCollection<DB>,
+  options: SyncPullOnceOptions,
+  pullStateOverride?: SyncPullRequestState
 ): Promise<SyncPullResponse> {
-  const pullState = await buildPullRequest(db, options);
+  const pullState = pullStateOverride ?? (await buildPullRequest(db, options));
   const { clientId, ...pullBody } = pullState.request;
   const combined = await transport.sync({ clientId, pull: pullBody });
   if (!combined.pull) {

package/src/push-engine.ts

@@ -7,6 +7,7 @@ import type {
   SyncPushResponse,
   SyncTransport,
 } from '@syncular/core';
+import { countSyncMetric } from '@syncular/core';
 import type { Kysely } from 'kysely';
 import { upsertConflictsForRejectedCommit } from './conflicts';
 import {
@@ -85,6 +86,7 @@ export async function syncPushOnce<DB extends SyncClientDb>(
   }
 
   let res: SyncPushResponse;
+  let usedWsPush = false;
   try {
     // Try WS push first if the transport supports it
     let wsResponse: SyncPushResponse | null = null;
@@ -94,6 +96,7 @@ export async function syncPushOnce<DB extends SyncClientDb>(
 
     if (wsResponse) {
       res = wsResponse;
+      usedWsPush = true;
     } else {
       // Fall back to HTTP
       const combined = await transport.sync({
@@ -156,6 +159,18 @@ export async function syncPushOnce<DB extends SyncClientDb>(
   }
 
   const responseJson = JSON.stringify(responseToUse);
+  const detectedConflicts = responseToUse.results.reduce(
+    (count, result) => count + (result.status === 'conflict' ? 1 : 0),
+    0
+  );
+  if (detectedConflicts > 0 && !usedWsPush) {
+    countSyncMetric('sync.conflicts.detected', detectedConflicts, {
+      attributes: {
+        source: 'client',
+        transport: 'http',
+      },
+    });
+  }
 
   if (responseToUse.status === 'applied' || responseToUse.status === 'cached') {
     await markOutboxCommitAcked(db, {

package/src/sync-loop.ts

@@ -14,7 +14,7 @@ import type {
 } from '@syncular/core';
 import type { Kysely } from 'kysely';
 import { upsertConflictsForRejectedCommit } from './conflicts';
-import type { ClientTableRegistry } from './handlers/registry';
+import type { ClientHandlerCollection } from './handlers/collection';
 import {
   getNextSendableOutboxCommit,
   markOutboxCommitAcked,
@@ -25,7 +25,9 @@ import type { SyncClientPluginContext } from './plugins/types';
 import {
   applyPullResponse,
   buildPullRequest,
+  createFollowupPullState,
   type SyncPullOnceOptions,
+  type SyncPullRequestState,
   syncPullOnce,
 } from './pull-engine';
 import { type SyncPushOnceOptions, syncPushOnce } from './push-engine';
@@ -64,6 +66,8 @@ async function syncPushUntilSettled<DB extends SyncClientDb>(
 interface SyncPullUntilSettledOptions extends SyncPullOnceOptions {
   /** Max pull rounds per call. Default: 20 */
   maxRounds?: number;
+  /** Optional prebuilt state from a prior pull round in the same sync cycle. */
+  initialPullState?: SyncPullRequestState;
 }
 
 interface SyncPullUntilSettledResult {
@@ -119,20 +123,23 @@ function mergePullResponse(
 async function syncPullUntilSettled<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
+  handlers: ClientHandlerCollection<DB>,
   options: SyncPullUntilSettledOptions
 ): Promise<SyncPullUntilSettledResult> {
   const maxRounds = Math.max(1, Math.min(1000, options.maxRounds ?? 20));
 
   const aggregatedBySubId = new Map<string, SyncPullSubscriptionResponse>();
+  let pullState =
+    options.initialPullState ?? (await buildPullRequest(db, options));
   let rounds = 0;
 
   for (let i = 0; i < maxRounds; i++) {
     rounds += 1;
-    const res = await syncPullOnce(db, transport, handlers, options);
+    const res = await syncPullOnce(db, transport, handlers, options, pullState);
     mergePullResponse(aggregatedBySubId, res);
 
     if (!needsAnotherPull(res)) break;
+    pullState = createFollowupPullState(pullState, res);
   }
 
   return {
@@ -182,7 +189,7 @@ export interface SyncOnceResult {
 async function syncOnceCombined<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
+  handlers: ClientHandlerCollection<DB>,
   options: SyncOnceOptions
 ): Promise<SyncOnceResult> {
   const pullOpts: SyncPullOnceOptions = {
@@ -348,6 +355,7 @@ async function syncOnceCombined<DB extends SyncClientDb>(
       const more = await syncPullUntilSettled(db, transport, handlers, {
         ...pullOpts,
         maxRounds: (options.maxPullRounds ?? 20) - 1,
+        initialPullState: createFollowupPullState(pullState, pullResponse),
       });
       pullRounds += more.rounds;
       mergePullResponse(aggregatedBySubId, more.response);
@@ -364,7 +372,7 @@ async function syncOnceCombined<DB extends SyncClientDb>(
 export async function syncOnce<DB extends SyncClientDb>(
   db: Kysely<DB>,
   transport: SyncTransport,
-  handlers: ClientTableRegistry<DB>,
+  handlers: ClientHandlerCollection<DB>,
   options: SyncOnceOptions
 ): Promise<SyncOnceResult> {
   return syncOnceCombined(db, transport, handlers, options);

package/src/sync.ts

@@ -0,0 +1,170 @@
+import type {
+  ColumnCodecDialect,
+  ColumnCodecSource,
+  ScopeDefinition,
+  ScopeValue,
+  ScopeValuesFromPatterns,
+  SyncSubscriptionRequest,
+} from '@syncular/core';
+import {
+  type CreateClientHandlerOptions,
+  createClientHandler,
+} from './handlers/create-handler';
+import type { ClientTableHandler } from './handlers/types';
+import type { SyncClientDb } from './schema';
+
+type ClientSyncSubscription<ScopeDefs extends readonly ScopeDefinition[]> =
+  Omit<SyncSubscriptionRequest, 'cursor' | 'table' | 'scopes'> & {
+    table: string;
+    scopes?: ScopeValuesFromPatterns<ScopeDefs>;
+  };
+
+type SharedTableName<DB extends SyncClientDb> = keyof DB & string;
+
+export type ClientSyncHandlerOptionsForTable<
+  DB extends SyncClientDb,
+  TableName extends SharedTableName<DB>,
+  ScopeDefs extends readonly ScopeDefinition[],
+  Identity,
+> = Omit<
+  CreateClientHandlerOptions<DB, TableName, ScopeDefs>,
+  'codecs' | 'codecDialect' | 'subscribe'
+> & {
+  codecs?: ColumnCodecSource;
+  codecDialect?: ColumnCodecDialect;
+  subscribe?:
+    | ClientSyncSubscription<ScopeDefs>
+    | ClientSyncSubscription<ScopeDefs>[]
+    | null
+    | ((args: {
+        identity: Identity;
+      }) =>
+        | ClientSyncSubscription<ScopeDefs>
+        | ClientSyncSubscription<ScopeDefs>[]
+        | null);
+};
+
+export interface ClientSyncConfig<
+  DB extends SyncClientDb = SyncClientDb,
+  Identity = { actorId: string },
+> {
+  handlers: ClientTableHandler<DB>[];
+  subscriptions(
+    identity: Identity
+  ): Array<Omit<SyncSubscriptionRequest, 'cursor'>>;
+}
+
+export interface DefineClientSyncOptions {
+  codecs?: ColumnCodecSource;
+  codecDialect?: ColumnCodecDialect;
+}
+
+export interface ClientSyncBuilder<
+  DB extends SyncClientDb,
+  ScopeDefs extends readonly ScopeDefinition[],
+  Identity,
+> extends ClientSyncConfig<DB, Identity> {
+  addHandler<TableName extends SharedTableName<DB>>(
+    options: ClientSyncHandlerOptionsForTable<
+      DB,
+      TableName,
+      ScopeDefs,
+      Identity
+    >
+  ): this;
+}
+
+export function defineClientSync<
+  DB extends SyncClientDb,
+  ScopeDefs extends readonly ScopeDefinition[],
+  Identity,
+>(
+  options: DefineClientSyncOptions
+): ClientSyncBuilder<DB, ScopeDefs, Identity> {
+  const handlers: ClientTableHandler<DB>[] = [];
+  const registeredTables = new Set<string>();
+  const subscriptionsByTable = new Map<
+    string,
+    ClientSyncHandlerOptionsForTable<
+      DB,
+      SharedTableName<DB>,
+      ScopeDefs,
+      Identity
+    >['subscribe']
+  >();
+
+  const toScopeValues = (
+    value: ScopeValuesFromPatterns<ScopeDefs> | undefined
+  ): Record<string, ScopeValue> => {
+    const result: Record<string, ScopeValue> = {};
+    for (const [key, scopeValue] of Object.entries(
+      (value ?? {}) as Record<string, ScopeValue | undefined>
+    )) {
+      if (scopeValue === undefined) continue;
+      result[key] = scopeValue;
+    }
+    return result;
+  };
+
+  const sync: ClientSyncBuilder<DB, ScopeDefs, Identity> = {
+    handlers,
+    addHandler<TableName extends SharedTableName<DB>>(
+      handlerOptions: ClientSyncHandlerOptionsForTable<
+        DB,
+        TableName,
+        ScopeDefs,
+        Identity
+      >
+    ) {
+      if (registeredTables.has(handlerOptions.table)) {
+        throw new Error(
+          `Client table handler already registered: ${handlerOptions.table}`
+        );
+      }
+
+      handlers.push(
+        createClientHandler({
+          ...handlerOptions,
+          subscribe: false,
+          codecs: options.codecs,
+          codecDialect: options.codecDialect,
+        })
+      );
+      subscriptionsByTable.set(
+        handlerOptions.table,
+        handlerOptions.subscribe as ClientSyncHandlerOptionsForTable<
+          DB,
+          SharedTableName<DB>,
+          ScopeDefs,
+          Identity
+        >['subscribe']
+      );
+      registeredTables.add(handlerOptions.table);
+      return sync;
+    },
+    subscriptions(
+      identity: Identity
+    ): Array<Omit<SyncSubscriptionRequest, 'cursor'>> {
+      const resolved: Array<Omit<SyncSubscriptionRequest, 'cursor'>> = [];
+      for (const [table, subscribe] of subscriptionsByTable.entries()) {
+        if (!subscribe) continue;
+        const value =
+          typeof subscribe === 'function' ? subscribe({ identity }) : subscribe;
+        if (!value) continue;
+        const entries = Array.isArray(value) ? value : [value];
+        for (const entry of entries) {
+          resolved.push({
+            id: entry.id,
+            table: entry.table ?? table,
+            scopes: toScopeValues(entry.scopes),
+            params: entry.params,
+            bootstrapState: entry.bootstrapState,
+          });
+        }
+      }
+      return resolved;
+    },
+  };
+
+  return sync;
+}

package/dist/handlers/registry.d.ts

@@ -1,15 +0,0 @@
-/**
- * @syncular/client - Sync client table registry
- */
-import type { ClientTableHandler } from './types';
-/**
- * Registry for client-side table handlers.
- */
-export declare class ClientTableRegistry<DB> {
-    private handlers;
-    register(handler: ClientTableHandler<DB>): this;
-    get(table: string): ClientTableHandler<DB> | undefined;
-    getOrThrow(table: string): ClientTableHandler<DB>;
-    getAll(): ClientTableHandler<DB>[];
-}
-//# sourceMappingURL=registry.d.ts.map

package/dist/handlers/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/handlers/registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;GAEG;AACH,qBAAa,mBAAmB,CAAC,EAAE;IACjC,OAAO,CAAC,QAAQ,CAA6C;IAE7D,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC,EAAE,CAAC,GAAG,IAAI,CAQ9C;IAED,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAAC,EAAE,CAAC,GAAG,SAAS,CAErD;IAED,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAAC,EAAE,CAAC,CAIhD;IAED,MAAM,IAAI,kBAAkB,CAAC,EAAE,CAAC,EAAE,CAEjC;CACF"}