@abloatai/ablo 0.15.0 → 0.15.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.15.1
+
+### Patch Changes
+
+- Loud 0-row writes: surface unmatched UPDATE/DELETE ids and add `AbloNotFoundError`
+
+  A commit now reports the ids of any UPDATE/DELETE that matched zero rows on
+  `CommitReceipt.missingIds`, and the new exported `AbloNotFoundError` lets typed
+  write wrappers throw instead of silently treating a missed write as success.
+  Additive and back-compatible (the field is omitted when nothing missed). This
+  unblocks the slides-sdk name-addressing / own-your-id work, which relies on a
+  loud failure when a stale id is written.
+
 ## 0.15.0
 
 ### Minor Changes
@@ -11,7 +24,7 @@
   **`onStale` redesigned — Stripe-aligned values (BREAKING).**
 
   The mode set is now `'reject' | 'overwrite' | 'notify'`. Each value names its outcome:
-  - **`notify` (new, non-coercive)** — the conflicting write is **held** (not applied) and the commit returns a `StaleNotification` carrying the conflicting field's *current* value, so the actor reconciles and re-commits rather than losing work. The rest of the batch still commits.
+  - **`notify` (new, non-coercive)** — the conflicting write is **held** (not applied) and the commit returns a `StaleNotification` carrying the conflicting field's _current_ value, so the actor reconciles and re-commits rather than losing work. The rest of the batch still commits.
   - **`overwrite`** (was `force`) — blind last-writer-wins, no signal.
   - **`reject`** (default, unchanged) — throws `AbloStaleContextError`.
 
@@ -33,10 +46,9 @@
   **Conflict policy.** `ConflictDecision` gains `{ action: 'notify' }`; `defaultPolicy` maps `onStale: 'notify'` → notify-and-hold, everything else → reject. `StaleContextConflict.requestedMode` is added so custom policies can honor the caller's declared intent.
 
 - **Data Source reverse-channel connector (new).** A customer Data Source can now **dial out** to the engine over a single outbound WebSocket (`ablo.source.v1` subprotocol) instead of exposing an inbound HTTP endpoint — the deployment shape private/VPC stores need.
-
   - **`createSourceConnector({ apiKey, handler, baseURL? })`** (new public API, exported from the root and `/source`) — opens one outbound socket (Node global `WebSocket`, no new dependency), with reconnect/backoff, and serves the customer's existing Data Source `handler`.
   - Server side: a connector registry + `/v1/source/listen` upgrade route bridge requests down / responses up, teed into `SourceClient` through the storage resolver.
-  - **Trust model unchanged:** the Standard-Webhooks HMAC is signed *above* the transport, so the socket carries the signed envelope byte-for-byte and the customer's `verifyAbloSourceRequest` is untouched. Transport changes, trust model doesn't.
+  - **Trust model unchanged:** the Standard-Webhooks HMAC is signed _above_ the transport, so the socket carries the signed envelope byte-for-byte and the customer's `verifyAbloSourceRequest` is untouched. Transport changes, trust model doesn't.
   - Opt-in per source via `reverse_channel_prod` (migration `20260622150000`); gated in `authorizeUpgrade`.
 
 ## 0.14.0

package/dist/client/Ablo.d.ts

@@ -469,6 +469,13 @@ export interface CommitReceipt {
      * resolve. Also fires on `conflict:notified`.
      */
     readonly notifications?: readonly StaleNotification[];
+    /**
+     * Ids of UPDATE/DELETE targets in this commit that matched ZERO rows (the row
+     * doesn't exist, or is outside the caller's org). Present (non-empty) only
+     * when a write missed. Typed resource wrappers turn this into a loud
+     * `AbloNotFoundError`; a raw `commits.create` caller can inspect it directly.
+     */
+    readonly missingIds?: readonly string[];
 }
 export interface CommitResource {
     create(options: CommitCreateOptions): Promise<CommitReceipt>;

package/dist/client/ApiClient.js

@@ -285,6 +285,9 @@ export function createProtocolClient(options) {
                 id: body.id ?? body.clientTxId ?? clientTxId,
                 status,
                 lastSyncId: body.lastSyncId,
+                ...(body.missingIds && body.missingIds.length > 0
+                    ? { missingIds: body.missingIds }
+                    : {}),
             };
         },
     };

package/dist/errors.d.ts

@@ -118,6 +118,21 @@ export declare class AbloConnectionError extends AbloError {
 export declare class AbloValidationError extends AbloError {
     readonly type: "AbloValidationError";
 }
+/**
+ * 404 — an UPDATE/DELETE addressed a row that doesn't exist (or is outside the
+ * caller's org). The engine reports such targets on `CommitReceipt.missingIds`;
+ * the typed resource wrappers raise this instead of returning a success receipt
+ * for a write that quietly matched zero rows. Carries the offending ids so a
+ * caller can see exactly which targets were absent.
+ */
+export declare class AbloNotFoundError extends AbloError {
+    readonly type: "AbloNotFoundError";
+    /** The id(s) that matched no row. */
+    readonly missingIds: readonly string[];
+    constructor(message: string, missingIds: readonly string[], options?: {
+        requestId?: string;
+    });
+}
 /** 5xx — server-side error. Usually retryable with backoff. */
 export declare class AbloServerError extends AbloError {
     readonly type: "AbloServerError";
@@ -272,6 +287,10 @@ export interface CommitReceipt {
     /** Number of operations metered. Reported on both success and
      *  rejection so quota systems see attempted work. */
     readonly ops?: number;
+    /** Ids of UPDATE/DELETE targets that matched ZERO rows (loud 0-row writes).
+     *  Present (non-empty) only when a write missed; typed wrappers raise
+     *  `AbloNotFoundError` from it. */
+    readonly missingIds?: readonly string[];
     /** Populated on rejection. `requiredCapability` (when present)
      *  carries the x402-style structured retry hint. */
     readonly error?: {

package/dist/errors.js

@@ -132,6 +132,27 @@ export class AbloConnectionError extends AbloError {
 export class AbloValidationError extends AbloError {
     type = 'AbloValidationError';
 }
+/**
+ * 404 — an UPDATE/DELETE addressed a row that doesn't exist (or is outside the
+ * caller's org). The engine reports such targets on `CommitReceipt.missingIds`;
+ * the typed resource wrappers raise this instead of returning a success receipt
+ * for a write that quietly matched zero rows. Carries the offending ids so a
+ * caller can see exactly which targets were absent.
+ */
+export class AbloNotFoundError extends AbloError {
+    type = 'AbloNotFoundError';
+    /** The id(s) that matched no row. */
+    missingIds;
+    constructor(message, missingIds, options) {
+        super(message, {
+            code: 'mutate_update_entity_not_found',
+            httpStatus: 404,
+            details: { missingIds },
+            ...(options?.requestId !== undefined ? { requestId: options.requestId } : {}),
+        });
+        this.missingIds = missingIds;
+    }
+}
 /** 5xx — server-side error. Usually retryable with backoff. */
 export class AbloServerError extends AbloError {
     type = 'AbloServerError';

package/dist/index.d.ts

@@ -59,7 +59,7 @@ export default Ablo;
 export { dataSource, abloSource, sourceEventForOperation, signAbloSourceRequest, verifyAbloSourceRequest, } from './source/index.js';
 export { createSourceConnector, type SourceConnector, type SourceConnectorOptions, type ConnectorStatus, } from './source/connector.js';
 export { defaultPolicy, capabilityPreemptPolicy } from './policy/index.js';
-export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloServerError, AbloStaleContextError, AbloClaimedError, CapabilityError, translateHttpError, hasWireCode, errorFromWire, toAbloError, ERROR_CODES, ERROR_CONTRACT_VERSION, errorCodeSpec, isRetryableCode, classifyRecovery, recoveryClassSchema, RECOVERY_CLASSES, } from './errors.js';
+export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloNotFoundError, AbloServerError, AbloStaleContextError, AbloClaimedError, CapabilityError, translateHttpError, hasWireCode, errorFromWire, toAbloError, ERROR_CODES, ERROR_CONTRACT_VERSION, errorCodeSpec, isRetryableCode, classifyRecovery, recoveryClassSchema, RECOVERY_CLASSES, } from './errors.js';
 export type { CommitReceipt, RequiredCapability } from './errors.js';
 export type { ErrorCode, WireErrorCode, ErrorCategory, ErrorCodeSpec, RecoveryClass } from './errors.js';
 export { WS_BEARER_SUBPROTOCOL_PREFIX, WS_SYNC_SUBPROTOCOL } from './auth/credentialSource.js';

package/dist/index.js

@@ -84,7 +84,7 @@ export { defaultPolicy, capabilityPreemptPolicy } from './policy/index.js';
 // Typed error hierarchy — Stripe-style. One import gets every class
 // consumers need to discriminate failures (`e instanceof AbloX` or
 // `e.type === 'AbloX'`) plus the HTTP-response translator.
-export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloServerError, AbloStaleContextError, AbloClaimedError, CapabilityError, translateHttpError, hasWireCode, errorFromWire, toAbloError, ERROR_CODES, ERROR_CONTRACT_VERSION, errorCodeSpec, isRetryableCode, classifyRecovery, recoveryClassSchema, RECOVERY_CLASSES, } from './errors.js';
+export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloNotFoundError, AbloServerError, AbloStaleContextError, AbloClaimedError, CapabilityError, translateHttpError, hasWireCode, errorFromWire, toAbloError, ERROR_CODES, ERROR_CONTRACT_VERSION, errorCodeSpec, isRetryableCode, classifyRecovery, recoveryClassSchema, RECOVERY_CLASSES, } from './errors.js';
 export { WS_BEARER_SUBPROTOCOL_PREFIX, WS_SYNC_SUBPROTOCOL } from './auth/credentialSource.js';
 export { ENVIRONMENTS, environmentSchema, normalizeEnvironment, environmentFromKeyPrefix, environmentToKeyPrefix, isSandboxEnvironment, } from './environment.js';
 // THE write-options contract — the one Zod schema for the option bag every

package/dist/interfaces/index.d.ts

@@ -148,6 +148,11 @@ export interface CommitResult {
      * receiving an `AbloStaleContextError`. See `StaleNotification`.
      */
     notifications?: StaleNotification[];
+    /**
+     * Ids of UPDATE/DELETE targets that matched ZERO rows (loud 0-row writes).
+     * Present (non-empty) only when a write missed.
+     */
+    missingIds?: string[];
 }
 /**
  * Per-call knobs attached to any mutation. Mirrors Stripe's options

package/dist/server/commit.d.ts

@@ -114,4 +114,13 @@ export interface CommitResult {
      * `StaleNotification` in `coordination/schema.ts`.
      */
     notifications?: StaleNotification[];
+    /**
+     * Ids of UPDATE/DELETE targets that matched ZERO rows — the row doesn't
+     * exist (or is outside the caller's org). The engine has always detected
+     * this (and logged it); surfacing it here lets the client turn a silent
+     * no-op into a loud `AbloNotFoundError`. Present (non-empty) only when at
+     * least one op missed. Ids are globally-unique uuids, so a caller can match
+     * its own target id against this set without ambiguity.
+     */
+    missingIds?: string[];
 }

package/dist/wire/frames.d.ts

@@ -122,6 +122,13 @@ export interface MutationResultMessage {
          * `conflict:notified` event and the commit receipt instead of rejecting.
          */
         notifications?: StaleNotification[];
+        /**
+         * Ids of UPDATE/DELETE targets that matched ZERO rows (don't exist or are
+         * outside the org). Present (non-empty) only when a write missed. The
+         * client turns this into a loud `AbloNotFoundError` for the affected
+         * caller instead of treating the no-op as success.
+         */
+        missingIds?: string[];
         error?: {
             code: ErrorCode;
             message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/ablo",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "The Collaboration Layer For AI Agents",
   "license": "Apache-2.0",
   "type": "module",