@abloatai/ablo 0.26.0 → 0.28.0

package/dist/transactions/replayValidation.d.ts

@@ -0,0 +1,182 @@
+/**
+ * The validation boundary for replaying persisted transactions after a restart.
+ *
+ * Rows read back from the on-disk transaction store may have been written by an
+ * earlier run — possibly by an older version of this package, possibly
+ * corrupted. Rather than trust them, the schemas here validate exactly the
+ * fields the transaction queue and the offline-mutation restore read during
+ * replay. A row that fails to parse is dropped and reported, never replayed as
+ * a malformed commit.
+ *
+ * The same store also holds two kinds of rows that are not replayable
+ * transactions — the offline mutation queue (`type: 'queue'`) and delta-await
+ * markers (`type: 'awaiting_delta'`), each owned by another part of the client.
+ * {@link isNonReplayablePersistedRow} recognizes them so they are skipped
+ * quietly rather than flagged as corruption.
+ */
+import { z } from 'zod';
+import type { Transaction } from './commitPayload.js';
+/**
+ * The shape of a persisted transaction that can be replayed: the fields the
+ * transaction queue reads when it re-enqueues the row — its id, operation type,
+ * model addressing, payload, and identity context. Any remaining bookkeeping is
+ * filled in with defaults when the row is rehydrated by
+ * {@link deserializePersistedTransaction}.
+ */
+export declare const persistedTransactionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        update: "update";
+        create: "create";
+        delete: "delete";
+        archive: "archive";
+        unarchive: "unarchive";
+    }>;
+    modelName: z.ZodString;
+    modelId: z.ZodString;
+    modelKey: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    previousData: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    context: z.ZodObject<{
+        userId: z.ZodString;
+        organizationId: z.ZodString;
+        role: z.ZodOptional<z.ZodString>;
+        teamIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    batchId: z.ZodOptional<z.ZodString>;
+    commitEnvelope: z.ZodOptional<z.ZodObject<{
+        idempotencyKey: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
+        operationIndex: z.ZodNumber;
+        operationCount: z.ZodNumber;
+        sealedAt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    sourceMutationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    writeOptions: z.ZodOptional<z.ZodObject<{
+        readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            reject: "reject";
+            overwrite: "overwrite";
+            notify: "notify";
+        }>>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    localOnly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type PersistedReplayableTransaction = z.infer<typeof persistedTransactionSchema>;
+/**
+ * Reports whether a stored row is one of the non-transaction kinds, so callers
+ * skip it instead of treating it as a corrupt transaction.
+ */
+export declare function isNonReplayablePersistedRow(row: unknown): boolean;
+/**
+ * Validates one stored row and rehydrates it into a {@link Transaction} ready
+ * to replay, or returns `null` when the row fails validation. Bookkeeping
+ * fields the stored row lacks — status, attempts, priority, timestamp — are
+ * re-derived the same way a freshly staged transaction derives them.
+ */
+export declare function deserializePersistedTransaction(row: unknown): Transaction | null;
+/**
+ * The shape of one entry in the persisted offline mutation queue — an item of
+ * the `'queue'` row's `mutations` array, carrying the fields read when the
+ * queue is restored on reconnect.
+ */
+export declare const persistedMutationSchema: z.ZodObject<{
+    mutationId: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        update: "update";
+        create: "create";
+        delete: "delete";
+        archive: "archive";
+    }>;
+    modelData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    modelName: z.ZodString;
+    timestamp: z.ZodString;
+    capturedChanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    writeOptions: z.ZodOptional<z.ZodObject<{
+        readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            reject: "reject";
+            overwrite: "overwrite";
+            notify: "notify";
+        }>>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type PersistedQueuedMutation = z.infer<typeof persistedMutationSchema>;
+export declare const PENDING_MUTATION_RECORD_PREFIX = "pending-mutation:";
+/**
+ * Stay one hour inside the server's 24-hour idempotency retention window.
+ * A journaled write older than this can no longer be deduplicated by the
+ * server, so restore holds it for review instead of replaying it.
+ */
+export declare const PENDING_MUTATION_REPLAY_WINDOW_MS: number;
+/** Scope-less records written by the first aggregate-journal release. */
+export declare const legacyPendingMutationRecordSchema: z.ZodObject<{
+    storageVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"pending_mutation">;
+    mutation: z.ZodObject<{
+        type: z.ZodEnum<{
+            update: "update";
+            create: "create";
+            delete: "delete";
+            archive: "archive";
+        }>;
+        modelData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        modelName: z.ZodString;
+        timestamp: z.ZodString;
+        capturedChanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        writeOptions: z.ZodOptional<z.ZodObject<{
+            readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                reject: "reject";
+                overwrite: "overwrite";
+                notify: "notify";
+            }>>>;
+            idempotencyKey: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        mutationId: z.ZodString;
+    }, z.core.$loose>;
+    timestamp: z.ZodNumber;
+}, z.core.$strict>;
+export declare const pendingMutationRecordSchema: z.ZodObject<{
+    storageVersion: z.ZodLiteral<2>;
+    scope: z.ZodObject<{
+        organizationId: z.ZodString;
+        participantId: z.ZodString;
+        namespace: z.ZodString;
+    }, z.core.$strict>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"pending_mutation">;
+    mutation: z.ZodObject<{
+        type: z.ZodEnum<{
+            update: "update";
+            create: "create";
+            delete: "delete";
+            archive: "archive";
+        }>;
+        modelData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        modelName: z.ZodString;
+        timestamp: z.ZodString;
+        capturedChanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        writeOptions: z.ZodOptional<z.ZodObject<{
+            readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                reject: "reject";
+                overwrite: "overwrite";
+                notify: "notify";
+            }>>>;
+            idempotencyKey: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        mutationId: z.ZodString;
+    }, z.core.$loose>;
+    timestamp: z.ZodNumber;
+}, z.core.$strict>;
+export type PendingMutationRecord = z.infer<typeof pendingMutationRecordSchema>;
+export declare function pendingMutationRecordId(mutationId: string): string;

package/dist/transactions/replayValidation.js

@@ -0,0 +1,156 @@
+/**
+ * The validation boundary for replaying persisted transactions after a restart.
+ *
+ * Rows read back from the on-disk transaction store may have been written by an
+ * earlier run — possibly by an older version of this package, possibly
+ * corrupted. Rather than trust them, the schemas here validate exactly the
+ * fields the transaction queue and the offline-mutation restore read during
+ * replay. A row that fails to parse is dropped and reported, never replayed as
+ * a malformed commit.
+ *
+ * The same store also holds two kinds of rows that are not replayable
+ * transactions — the offline mutation queue (`type: 'queue'`) and delta-await
+ * markers (`type: 'awaiting_delta'`), each owned by another part of the client.
+ * {@link isNonReplayablePersistedRow} recognizes them so they are skipped
+ * quietly rather than flagged as corruption.
+ */
+import { z } from 'zod';
+import { computePriorityScore, normalizeModelKey } from './commitPayload.js';
+import { commitEnvelopeMemberSchema, commitOutboxScopeSchema, } from './commitEnvelope.js';
+/** The subset of a write's options that is stored with each transaction or queued mutation. */
+const persistedWriteOptionsSchema = z
+    .object({
+    readAt: z.number().nullable().optional(),
+    onStale: z.enum(['reject', 'overwrite', 'notify']).nullable().optional(),
+    idempotencyKey: z.string().optional(),
+    label: z.string().optional(),
+})
+    .loose();
+/**
+ * The shape of a persisted transaction that can be replayed: the fields the
+ * transaction queue reads when it re-enqueues the row — its id, operation type,
+ * model addressing, payload, and identity context. Any remaining bookkeeping is
+ * filled in with defaults when the row is rehydrated by
+ * {@link deserializePersistedTransaction}.
+ */
+export const persistedTransactionSchema = z
+    .object({
+    id: z.string().min(1),
+    type: z.enum(['create', 'update', 'delete', 'archive', 'unarchive']),
+    modelName: z.string().min(1),
+    modelId: z.string().min(1),
+    modelKey: z.string().min(1).optional(),
+    data: z.record(z.string(), z.unknown()).optional(),
+    previousData: z.record(z.string(), z.unknown()).nullable().optional(),
+    context: z.object({
+        userId: z.string().min(1),
+        organizationId: z.string().min(1),
+        role: z.string().optional(),
+        teamIds: z.array(z.string()).optional(),
+    }),
+    createdAt: z.number().optional(),
+    batchId: z.string().optional(),
+    commitEnvelope: commitEnvelopeMemberSchema.optional(),
+    sourceMutationIds: z.array(z.string().min(1)).optional(),
+    writeOptions: persistedWriteOptionsSchema.optional(),
+    localOnly: z.boolean().optional(),
+})
+    .loose();
+/** The `type` values of stored rows that belong to other parts of the client and are not replayable transactions. */
+const NON_REPLAYABLE_TYPES = new Set([
+    'queue',
+    'awaiting_delta',
+    'pending_mutation',
+    'commit_envelope',
+    'http_commit_envelope',
+]);
+/**
+ * Reports whether a stored row is one of the non-transaction kinds, so callers
+ * skip it instead of treating it as a corrupt transaction.
+ */
+export function isNonReplayablePersistedRow(row) {
+    return (typeof row === 'object' &&
+        row !== null &&
+        typeof row.type === 'string' &&
+        NON_REPLAYABLE_TYPES.has(row.type));
+}
+/**
+ * Validates one stored row and rehydrates it into a {@link Transaction} ready
+ * to replay, or returns `null` when the row fails validation. Bookkeeping
+ * fields the stored row lacks — status, attempts, priority, timestamp — are
+ * re-derived the same way a freshly staged transaction derives them.
+ */
+export function deserializePersistedTransaction(row) {
+    const parsed = persistedTransactionSchema.safeParse(row);
+    if (!parsed.success)
+        return null;
+    const tx = parsed.data;
+    return {
+        id: tx.id,
+        type: tx.type,
+        modelName: tx.modelName,
+        modelId: tx.modelId,
+        modelKey: tx.modelKey ?? normalizeModelKey(tx.modelName),
+        ...(tx.data !== undefined ? { data: tx.data } : {}),
+        ...(tx.previousData !== undefined ? { previousData: tx.previousData } : {}),
+        context: tx.context,
+        status: 'pending',
+        createdAt: tx.createdAt ?? Date.now(),
+        attempts: 0,
+        priority: 'normal',
+        priorityScore: computePriorityScore(tx.type, tx.modelName),
+        ...(tx.batchId !== undefined ? { batchId: tx.batchId } : {}),
+        ...(tx.commitEnvelope !== undefined
+            ? { commitEnvelope: tx.commitEnvelope }
+            : {}),
+        ...(tx.sourceMutationIds !== undefined
+            ? { sourceMutationIds: tx.sourceMutationIds }
+            : {}),
+        ...(tx.writeOptions !== undefined ? { writeOptions: tx.writeOptions } : {}),
+        ...(tx.localOnly !== undefined ? { localOnly: tx.localOnly } : {}),
+    };
+}
+/**
+ * The shape of one entry in the persisted offline mutation queue — an item of
+ * the `'queue'` row's `mutations` array, carrying the fields read when the
+ * queue is restored on reconnect.
+ */
+export const persistedMutationSchema = z
+    .object({
+    mutationId: z.string().min(1).optional(),
+    type: z.enum(['create', 'update', 'delete', 'archive']),
+    modelData: z.record(z.string(), z.unknown()),
+    modelName: z.string().min(1),
+    timestamp: z.string(),
+    capturedChanges: z.record(z.string(), z.unknown()).optional(),
+    writeOptions: persistedWriteOptionsSchema.optional(),
+})
+    .loose();
+export const PENDING_MUTATION_RECORD_PREFIX = 'pending-mutation:';
+/**
+ * Stay one hour inside the server's 24-hour idempotency retention window.
+ * A journaled write older than this can no longer be deduplicated by the
+ * server, so restore holds it for review instead of replaying it.
+ */
+export const PENDING_MUTATION_REPLAY_WINDOW_MS = 23 * 60 * 60 * 1000;
+const pendingMutationRecordBaseShape = {
+    id: z.string().startsWith(PENDING_MUTATION_RECORD_PREFIX),
+    type: z.literal('pending_mutation'),
+    mutation: persistedMutationSchema.extend({
+        mutationId: z.string().min(1),
+    }),
+    timestamp: z.number().int().nonnegative(),
+};
+/** Scope-less records written by the first aggregate-journal release. */
+export const legacyPendingMutationRecordSchema = z.strictObject({
+    ...pendingMutationRecordBaseShape,
+    storageVersion: z.literal(1),
+});
+export const pendingMutationRecordSchema = z.strictObject({
+    ...pendingMutationRecordBaseShape,
+    storageVersion: z.literal(2),
+    scope: commitOutboxScopeSchema,
+});
+export function pendingMutationRecordId(mutationId) {
+    return `${PENDING_MUTATION_RECORD_PREFIX}${mutationId}`;
+}

package/dist/types/global.d.ts

@@ -1,23 +1,24 @@
 /**
- * Type registration point for SDK consumers.
+ * The single place where you tell the SDK about your application's types.
  *
- * A consumer registers their Schema, Presence, Claims, and UserMeta ONCE by
- * augmenting the {@link Register} interface, and every SDK hook — `useAblo`,
- * `useQuery`, `useOne`, `usePresence`, `useClaim` — reads its types from the
- * resolved registration. No generics at call sites, no `schema` arg per call.
+ * You register your Schema, Presence, Claims, and UserMeta once by augmenting
+ * the {@link Register} interface. From then on every SDK hook — `useAblo`,
+ * `useQuery`, `useOne`, `usePresence`, `useClaim` — reads its types from that
+ * registration, so you never pass a generic or a `schema` argument at a call
+ * site.
  *
- * Registration is done via **module augmentation** of `@abloatai/ablo` —
- * the same pattern TanStack Router uses for its `Register` interface. The brand
- * lives in the module specifier, so the interface is just `Register` (not a
- * global, not prefixed). It's a language feature, not a library trick: any file
- * in the compilation can augment it and every resolver below picks it up.
+ * Registration uses TypeScript module augmentation: any file in your project
+ * can add an `interface Register` to a `declare module '@abloatai/ablo'`
+ * block, and every resolver below picks it up. Because the name is scoped to
+ * this module, the interface is simply `Register` — not a global and not
+ * prefixed.
  *
- * Consumer example (`npx ablo init` scaffolds this as `ablo/register.ts`, a
- * sibling of `ablo/schema.ts`). It's a regular `.ts` module, NOT a hand-authored
- * `.d.ts`: the top-level `import type { schema }` makes the `declare module`
- * block MERGE (augment) this interface rather than collide with it — the same
- * shape TanStack Router uses in `src/router.tsx`. Any `.ts` file in the
- * `tsconfig` `include` works; it never needs to be imported.
+ * The `npx ablo init` command scaffolds this file as `ablo/register.ts`, next
+ * to `ablo/schema.ts`. Write it as a normal `.ts` module, not a hand-authored
+ * `.d.ts`: the top-level `import type { schema }` is what makes the
+ * `declare module` block merge into this interface rather than collide with it.
+ * Any `.ts` file covered by your `tsconfig` works, and it never needs to be
+ * imported anywhere.
  *
  * ```ts
  * // ablo/register.ts
@@ -34,15 +35,15 @@
  * export {};
  * ```
  *
- * If `Register` is never augmented, every resolver falls back to
- * {@link DefaultSyncShape} — a loose shape that keeps consumers compiling
- * without typed benefits until they opt in.
+ * When `Register` is never augmented, every resolver falls back to
+ * {@link DefaultSyncShape} — a loose shape that keeps your code compiling
+ * without typed results until you opt in.
  */
 /**
- * Default fallback shapes used when the consumer hasn't augmented
- * {@link Register}. `DefaultSyncShape.Schema` is intentionally structural — it
- * carries `{ models: Record<string, unknown> }` so hooks can still validate the
- * model key argument against *something*, just without a typed entity shape.
+ * The fallback shapes the resolvers use when {@link Register} has not been
+ * augmented. `DefaultSyncShape.Schema` is deliberately structural — it carries
+ * `{ models: Record<string, unknown> }` so hooks can still check a model-key
+ * argument against something, just without a typed entity shape behind it.
  */
 export interface DefaultSyncShape {
     readonly Schema: {
@@ -55,20 +56,21 @@ export interface DefaultSyncShape {
     };
 }
 /**
- * The registration interface. Consumers augment it via
- * `declare module '@abloatai/ablo' { interface Register { Schema: ...; … } }`.
- * Empty by default — every SDK resolver falls back to {@link DefaultSyncShape}
- * when an expected key is absent. Exported from the package root so the module
- * augmentation merges into this declaration.
+ * The registration interface you augment to declare your application's types.
+ * Add keys inside a `declare module '@abloatai/ablo'` block — for example
+ * `interface Register { Schema: ...; Presence: ...; }`. It is empty by default,
+ * so any key you omit falls back to {@link DefaultSyncShape}. It is exported
+ * from the package root so your augmentation merges into this declaration.
  *
- * The `Schema` augmentation key holds the type produced by `defineSchema`, so
- * the same noun reads consistently here and in {@link ResolveSchema}.
+ * The `Schema` key holds the type returned by `defineSchema`, and
+ * {@link ResolveSchema} reads it back out.
  */
 export interface Register {
 }
 /**
- * The consumer's schema, or the default shape if unregistered. Hooks use this
- * to type their model-key argument and infer the entity type returned.
+ * Your registered schema, or the default shape when none is registered. Hooks
+ * read this to type their model-key argument and to infer the entity type they
+ * return.
  */
 export type ResolveSchema = Register extends {
     Schema: infer S;
@@ -76,30 +78,33 @@ export type ResolveSchema = Register extends {
     models: Record<string, unknown>;
 } ? S : DefaultSyncShape['Schema'] : DefaultSyncShape['Schema'];
 /**
- * The consumer's presence shape, or the default if unregistered. Used by
- * `usePresence`. Free-form — any serializable JSON broadcast per session.
+ * Your registered presence shape, or the default when none is registered.
+ * `usePresence` reads it. The shape is free-form — any JSON-serializable value
+ * you broadcast per session.
  */
 export type ResolvePresence = Register extends {
     Presence: infer P;
 } ? P : DefaultSyncShape['Presence'];
 /**
- * The consumer's claim vocabulary, or the default if unregistered. Keys are
- * claim names; values are the claim payload for each claim. Used by
- * `useClaim(claimName)`.
+ * Your registered claim vocabulary, or the default when none is registered.
+ * Each key is a claim name and its value is that claim's payload.
+ * `useClaim(claimName)` reads it.
  */
 export type ResolveClaims = Register extends {
     Claims: infer I;
 } ? I : DefaultSyncShape['Claims'];
 /**
- * The consumer's user-metadata shape, or the default if unregistered. Carries
- * identity info the consumer trusts from their auth layer — not SDK-validated.
+ * Your registered user-metadata shape, or the default when none is registered.
+ * It carries identity information you trust from your own auth layer; the SDK
+ * does not validate it.
  */
 export type ResolveUserMeta = Register extends {
     UserMeta: infer U;
 } ? U : DefaultSyncShape['UserMeta'];
 /**
- * The keys of the consumer's schema models. `useQuery(modelKey)` narrows its
- * first argument to this union, so unknown key literals fail at compile time.
+ * The union of your schema's model names. `useQuery(modelKey)` narrows its
+ * first argument to this union, so a misspelled or unknown model name fails at
+ * compile time.
  */
 export type ResolveModelKey = ResolveSchema extends {
     models: infer M;

package/dist/types/global.js

@@ -1,23 +1,24 @@
 /**
- * Type registration point for SDK consumers.
+ * The single place where you tell the SDK about your application's types.
  *
- * A consumer registers their Schema, Presence, Claims, and UserMeta ONCE by
- * augmenting the {@link Register} interface, and every SDK hook — `useAblo`,
- * `useQuery`, `useOne`, `usePresence`, `useClaim` — reads its types from the
- * resolved registration. No generics at call sites, no `schema` arg per call.
+ * You register your Schema, Presence, Claims, and UserMeta once by augmenting
+ * the {@link Register} interface. From then on every SDK hook — `useAblo`,
+ * `useQuery`, `useOne`, `usePresence`, `useClaim` — reads its types from that
+ * registration, so you never pass a generic or a `schema` argument at a call
+ * site.
  *
- * Registration is done via **module augmentation** of `@abloatai/ablo` —
- * the same pattern TanStack Router uses for its `Register` interface. The brand
- * lives in the module specifier, so the interface is just `Register` (not a
- * global, not prefixed). It's a language feature, not a library trick: any file
- * in the compilation can augment it and every resolver below picks it up.
+ * Registration uses TypeScript module augmentation: any file in your project
+ * can add an `interface Register` to a `declare module '@abloatai/ablo'`
+ * block, and every resolver below picks it up. Because the name is scoped to
+ * this module, the interface is simply `Register` — not a global and not
+ * prefixed.
  *
- * Consumer example (`npx ablo init` scaffolds this as `ablo/register.ts`, a
- * sibling of `ablo/schema.ts`). It's a regular `.ts` module, NOT a hand-authored
- * `.d.ts`: the top-level `import type { schema }` makes the `declare module`
- * block MERGE (augment) this interface rather than collide with it — the same
- * shape TanStack Router uses in `src/router.tsx`. Any `.ts` file in the
- * `tsconfig` `include` works; it never needs to be imported.
+ * The `npx ablo init` command scaffolds this file as `ablo/register.ts`, next
+ * to `ablo/schema.ts`. Write it as a normal `.ts` module, not a hand-authored
+ * `.d.ts`: the top-level `import type { schema }` is what makes the
+ * `declare module` block merge into this interface rather than collide with it.
+ * Any `.ts` file covered by your `tsconfig` works, and it never needs to be
+ * imported anywhere.
  *
  * ```ts
  * // ablo/register.ts
@@ -34,8 +35,8 @@
  * export {};
  * ```
  *
- * If `Register` is never augmented, every resolver falls back to
- * {@link DefaultSyncShape} — a loose shape that keeps consumers compiling
- * without typed benefits until they opt in.
+ * When `Register` is never augmented, every resolver falls back to
+ * {@link DefaultSyncShape} — a loose shape that keeps your code compiling
+ * without typed results until you opt in.
  */
 export {};