@abloatai/ablo 0.10.1 → 0.11.0

package/dist/ai-sdk/wrap.js

@@ -28,15 +28,15 @@
  * ```
  */
 import { wrapLanguageModel } from 'ai';
-import { intentBroadcastMiddleware, } from './intent-broadcast.js';
+import { claimBroadcastMiddleware, } from './claim-broadcast.js';
 import { coordinationContextMiddleware } from './coordination-context.js';
 export function wrapWithMultiplayer(options) {
-    const { model, agent, target, action, description, excludeIntentIds, extraMiddleware } = options;
+    const { model, agent, target, action, description, excludeClaimIds, extraMiddleware } = options;
     return wrapLanguageModel({
         model,
         middleware: [
-            coordinationContextMiddleware({ agent, target, excludeIntentIds }),
-            intentBroadcastMiddleware({ agent, target, action, description }),
+            coordinationContextMiddleware({ agent, target, excludeClaimIds }),
+            claimBroadcastMiddleware({ agent, target, action, description }),
             ...(extraMiddleware ?? []),
         ],
     });

package/dist/api/index.d.ts

@@ -4,7 +4,7 @@
  * Use this build for serverless functions, scripts, and backends that want
  * model reads/writes and commits over HTTP without the realtime sync runtime.
  */
-export { createProtocolClient, createProtocolClient as Ablo, type AbloApi, type AbloApiClientOptions, type AbloApiIntents, type Capability, type CapabilityCreateOptions, type CapabilityParticipantKind, type CapabilityRecord, type CapabilityResource, type CapabilityRevocation, type CapabilityScope, } from '../client/ApiClient.js';
-export type { CommitCreateOptions, CommitOperationInput, CommitReceipt, CommitWait, IntentCreateOptions, IntentHandle, IntentWaitOptions, ClaimedOptions, IfClaimedPolicy, ModelClient, ModelClaim, ModelMutationOptions, ModelReadOptions, ModelRead, ModelTarget, } from '../client/Ablo.js';
+export { createProtocolClient, createProtocolClient as Ablo, type AbloApi, type AbloApiClientOptions, type AbloApiClaims, type Capability, type CapabilityCreateOptions, type CapabilityParticipantKind, type CapabilityRecord, type CapabilityResource, type CapabilityRevocation, type CapabilityScope, } from '../client/ApiClient.js';
+export type { CommitCreateOptions, CommitOperationInput, CommitReceipt, CommitWait, ClaimCreateOptions, ClaimHandle, ClaimWaitOptions, ClaimedOptions, IfClaimedPolicy, ModelClient, ModelClaim, ModelMutationOptions, ModelReadOptions, ModelRead, ModelTarget, } from '../client/Ablo.js';
 import { createProtocolClient } from '../client/ApiClient.js';
 export default createProtocolClient;

package/dist/cli.cjs

@@ -212180,11 +212180,11 @@ var require_commonjs2 = __commonJS({
               if (pad) {
                 const need = width - c.length;
                 if (need > 0) {
-                  const z4 = new Array(need + 1).join("0");
+                  const z6 = new Array(need + 1).join("0");
                   if (i < 0) {
-                    c = "-" + z4 + c.slice(1);
+                    c = "-" + z6 + c.slice(1);
                   } else {
-                    c = z4 + c;
+                    c = z6 + c;
                   }
                 }
               }
@@ -276682,8 +276682,8 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
       if (i) process.stdout.write(`${I2}  ${l2}...`);
       else if (t === "timer") process.stdout.write(`${I2}  ${l2} ${O2(g2)}`);
       else {
-        const z4 = ".".repeat(Math.floor(w2)).slice(0, 3);
-        process.stdout.write(`${I2}  ${l2}${z4}`);
+        const z6 = ".".repeat(Math.floor(w2)).slice(0, 3);
+        process.stdout.write(`${I2}  ${l2}${z6}`);
       }
       h2 = h2 + 1 < n.length ? h2 + 1 : 0, w2 = w2 < n.length ? w2 + 0.125 : 0;
     }, r2);
@@ -276710,7 +276710,7 @@ init_cjs_shims();
 
 // src/errors.ts
 init_cjs_shims();
-var import_zod2 = require("zod");
+var import_zod4 = require("zod");
 
 // src/errorCodes.ts
 init_cjs_shims();
@@ -276786,7 +276786,7 @@ var ERROR_CODES = {
   byo_role_unreadable: wire("permission", 403, false, "The direct Postgres connector role could not be introspected."),
   byo_tenant_tables_unforced_rls: wire("permission", 403, false, "Tenant tables do not have RLS forced under the direct Postgres connector role."),
   byo_host_not_allowed: wire("permission", 403, false, "The direct Postgres connector host resolves to a private, loopback, or link-local address and cannot be used."),
-  // ── claim / intent conflict (409) ──────────────────────────────────
+  // ── claim / claim conflict (409) ──────────────────────────────────
   // Held-claim rejections are NOT queue-retryable (gRPC FAILED_PRECONDITION /
   // ABORTED semantics; Replicache/Zero SETTLE a rejected mutation — reject the
   // caller, roll back the optimistic effect — instead of resending it).
@@ -276799,8 +276799,8 @@ var ERROR_CODES = {
   claim_conflict: wire("claim", 409, false, "The target entity is claimed by another participant."),
   claim_lost: wire("claim", 409, false, "A previously held claim was lost before the write applied."),
   entity_claimed: wire("claim", 409, false, "The target entity is currently claimed; write was blocked."),
-  intent_conflict: wire("claim", 409, false, "An intent on the target conflicts with an active intent (server-internal alias of claim_conflict)."),
   malformed_claim: wire("claim", 400, false, "The claim payload was malformed."),
+  malformed_subscription: wire("validation", 400, false, "The update_subscription payload was malformed; expected { syncGroups: string[] }."),
   model_claimed: wire("claim", 409, false, "The model instance is claimed by another participant."),
   model_claimed_timeout: wire("claim", 409, false, "Timed out waiting for a model claim to clear."),
   model_claim_not_configured: client("claim", "Claiming was requested on a model that has no claim configuration."),
@@ -276809,7 +276809,7 @@ var ERROR_CODES = {
   idempotency_conflict: wire("conflict", 409, false, "The same Idempotency-Key was reused with a different request body."),
   idempotency_key_too_long: wire("validation", 400, false, "The supplied Idempotency-Key exceeds the maximum length."),
   // ── validation (400 / 422) ─────────────────────────────────────────
-  write_options_invalid: client("validation", "The write options (`idempotencyKey` / `label` / `wait` / `readAt` / `onStale` / `intent`) failed validation against the write-options schema."),
+  write_options_invalid: client("validation", "The write options (`idempotencyKey` / `label` / `wait` / `readAt` / `onStale` / `claim`) failed validation against the write-options schema."),
   source_operation_id_required: client("validation", "A data-source operation arrived without the entity `id` it targets."),
   source_adapter_misconfigured: client("validation", "The data-source ORM adapter could not map a schema model onto the backing client (missing delegate or model)."),
   source_event_invalid: client("validation", "A data-source outbox event could not be built \u2014 the operation carries no entity id and none was supplied."),
@@ -276867,15 +276867,15 @@ var ERROR_CODES = {
   required_field_added: client("schema", "Migration adds a new required field."),
   enum_value_removed: client("schema", "Migration removes an enum value (destructive classification)."),
   risky_cast: client("schema", "Migration would perform a risky column type cast."),
-  // ── intent / lease (409 / transport) ───────────────────────────────
-  intent_lease_unavailable: wire("intent", 503, true, "The intent-lease coordination subsystem is unavailable; retry."),
-  intent_not_wired: client("intent", "Intent support was used but is not wired in this runtime."),
-  intent_queued: wire("intent", 409, true, "The intent was queued behind an active lease holder."),
-  intent_wait_aborted: wire("intent", 409, true, "Waiting for the intent lease was aborted."),
-  intent_wait_poll_interval_required: client("intent", "A poll interval is required when waiting on an intent."),
-  grant_timeout: wire("intent", 504, true, "Timed out waiting for a capability grant."),
-  slide_intent_missing_deck_id: wire("intent", 400, false, "A slide intent was missing its deck id."),
-  slide_intent_unknown_sibling: wire("intent", 400, false, "A slide intent referenced an unknown sibling slide."),
+  // ── claim / lease (409 / transport) ───────────────────────────────
+  claim_lease_unavailable: wire("claim", 503, true, "The claim-lease coordination subsystem is unavailable; retry."),
+  claim_not_wired: client("claim", "Claim support was used but is not wired in this runtime."),
+  claim_queued: wire("claim", 409, true, "The claim was queued behind an active lease holder."),
+  claim_wait_aborted: wire("claim", 409, true, "Waiting for the claim lease was aborted."),
+  claim_wait_poll_interval_required: client("claim", "A poll interval is required when waiting on an claim."),
+  grant_timeout: wire("claim", 504, true, "Timed out waiting for a capability grant."),
+  slide_intent_missing_deck_id: wire("claim", 400, false, "A slide claim was missing its deck id."),
+  slide_intent_unknown_sibling: wire("claim", 400, false, "A slide claim referenced an unknown sibling slide."),
   // ── bootstrap (transport) ──────────────────────────────────────────
   bootstrap_fetch_timeout: wire("bootstrap", 504, true, "The bootstrap fetch timed out."),
   bootstrap_offline: wire("bootstrap", 503, true, "Bootstrap could not run because the client is offline."),
@@ -276978,7 +276978,7 @@ var ERROR_CODES = {
   upload_items_required: wire("validation", 400, false, "The request must include a non-empty items array."),
   presigned_url_failed: wire("server", 500, true, "Failed to generate a presigned upload URL."),
   task_id_required: wire("validation", 400, false, "A task id is required for this request."),
-  intent_id_required: wire("validation", 400, false, "An intent id is required for this request."),
+  claim_id_required: wire("validation", 400, false, "An claim id is required for this request."),
   commit_operation_action_required: wire("validation", 400, false, "A commit operation is missing its `action`."),
   commit_operation_unsupported: wire("validation", 400, false, "A commit operation used an unsupported `action`."),
   usage_invalid: wire("validation", 400, false, "The usage request was invalid."),
@@ -276993,12 +276993,210 @@ var ERROR_CODES = {
   parent_turn_foreign_agent: wire("permission", 403, false, "The parent turn belongs to a different agent."),
   turn_not_found: wire("not_found", 404, false, "The referenced turn does not exist."),
   turn_foreign_agent: wire("permission", 403, false, "The turn belongs to a different agent."),
-  invalid_intent: wire("validation", 400, false, "The intent request was invalid."),
+  invalid_intent: wire("validation", 400, false, "The claim request was invalid."),
   schema_too_large: wire("validation", 413, false, "The submitted schema exceeds the maximum size."),
   invalid_schema: wire("validation", 400, false, "The submitted schema could not be parsed."),
   incompatible_change: wire("conflict", 409, false, "The schema change is incompatible with the current schema.")
 };
 
+// src/coordination/schema.ts
+init_cjs_shims();
+var import_zod3 = require("zod");
+
+// src/schema/roles.ts
+init_cjs_shims();
+var import_zod2 = require("zod");
+var syncGroupSchema = import_zod2.z.templateLiteral([import_zod2.z.string().regex(/^[a-z][a-z0-9_]*$/), ":", import_zod2.z.string().min(1)]).brand();
+var syncGroupInputSchema = import_zod2.z.union([import_zod2.z.literal("default"), syncGroupSchema]);
+var roleSourceSchema = import_zod2.z.object({
+  /** The context field to read, e.g. `'organizationId'`, `'id'`, `'deckId'`. */
+  field: import_zod2.z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "source must be a valid identifier"),
+  /**
+   * When `true`, `field` holds an array; every non-empty string element yields
+   * one group. When `false` (default), `field` is a scalar; truthy → one group.
+   */
+  multi: import_zod2.z.boolean()
+});
+var roleSchema = import_zod2.z.object({
+  kind: import_zod2.z.string().regex(/^[a-z][a-z0-9_]*$/, 'kind must be a lowercase identifier, e.g. "deck"'),
+  source: roleSourceSchema
+});
+var scopeSchema = import_zod2.z.union([
+  import_zod2.z.boolean(),
+  import_zod2.z.string().regex(/^[a-z][a-z0-9_]*$/, 'scope kind must be a lowercase identifier, e.g. "dataroom"')
+]);
+var grantsRefSchema = import_zod2.z.object({
+  subject: import_zod2.z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "grants.subject must name a relation"),
+  scope: import_zod2.z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "grants.scope must name a relation")
+});
+
+// src/coordination/schema.ts
+var targetRangeSchema = import_zod3.z.object({
+  startLine: import_zod3.z.number(),
+  endLine: import_zod3.z.number(),
+  startColumn: import_zod3.z.number().optional(),
+  endColumn: import_zod3.z.number().optional()
+});
+var participantKindSchema = import_zod3.z.enum(["user", "agent", "system"]);
+var wireParticipantKindSchema = import_zod3.z.preprocess(
+  (value) => value === "human" ? "user" : value,
+  participantKindSchema
+);
+var targetRefSchema = import_zod3.z.object({
+  entityType: import_zod3.z.string(),
+  entityId: import_zod3.z.string(),
+  path: import_zod3.z.string().optional(),
+  range: targetRangeSchema.optional(),
+  field: import_zod3.z.string().optional(),
+  meta: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+});
+var onStaleModeSchema = import_zod3.z.enum(["reject", "force", "flag", "merge"]);
+var writeGuardSchema = import_zod3.z.object({
+  readAt: import_zod3.z.number().nullish(),
+  onStale: onStaleModeSchema.nullish(),
+  bypass: import_zod3.z.boolean().optional()
+});
+var claimStatusSchema = import_zod3.z.enum([
+  "active",
+  "committed",
+  "expired",
+  "canceled"
+]);
+var wireClaimBaseSchema = targetRefSchema.extend({
+  claimId: import_zod3.z.string(),
+  /** Verb the agent expects: 'update' | 'create' | 'editing' | 'reviewing' … */
+  action: import_zod3.z.string(),
+  /** Server-stamped declaration time (epoch ms). */
+  declaredAt: import_zod3.z.number(),
+  /** Server-computed TTL deadline (epoch ms). Readers treat as advisory. */
+  expiresAt: import_zod3.z.number(),
+  status: claimStatusSchema.optional()
+});
+var wireClaimSummarySchema = wireClaimBaseSchema.pick({
+  claimId: true,
+  action: true,
+  declaredAt: true,
+  expiresAt: true,
+  entityType: true,
+  entityId: true,
+  field: true,
+  meta: true
+});
+var claimErrorSchema = import_zod3.z.object({
+  code: import_zod3.z.string(),
+  message: import_zod3.z.string().optional(),
+  /** Participant already holding the target (conflict rejections). */
+  heldBy: import_zod3.z.string().optional(),
+  heldByClaimId: import_zod3.z.string().optional(),
+  heldByExpiresAt: import_zod3.z.number().optional(),
+  /** Rich holder context for conflict rejections. Additive: older frames omit it. */
+  heldByClaim: wireClaimSummarySchema.optional(),
+  /** Optional conflict-policy explanation. Additive: older frames omit it. */
+  policyReason: import_zod3.z.string().optional()
+});
+var wireClaimSchema = wireClaimBaseSchema.extend({
+  error: claimErrorSchema.optional()
+});
+var claimRejectionSchema = import_zod3.z.object({
+  claimId: import_zod3.z.string(),
+  reason: import_zod3.z.string(),
+  target: targetRefSchema.optional(),
+  heldBy: import_zod3.z.string().optional(),
+  heldByClaimId: import_zod3.z.string().optional(),
+  heldByExpiresAt: import_zod3.z.number().optional(),
+  heldByClaim: wireClaimSummarySchema.optional(),
+  policyReason: import_zod3.z.string().optional()
+});
+var modelTargetSchema = import_zod3.z.object({
+  model: import_zod3.z.string(),
+  id: import_zod3.z.string(),
+  path: import_zod3.z.string().optional(),
+  range: targetRangeSchema.optional(),
+  field: import_zod3.z.string().optional(),
+  meta: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+}).readonly();
+var modelClaimSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  actor: import_zod3.z.string(),
+  participantKind: wireParticipantKindSchema,
+  action: import_zod3.z.string(),
+  description: import_zod3.z.string().optional(),
+  field: import_zod3.z.string().optional(),
+  status: import_zod3.z.enum(["active", "queued"]).optional(),
+  position: import_zod3.z.number().optional(),
+  expiresAt: import_zod3.z.number(),
+  target: modelTargetSchema
+}).readonly();
+var claimBeginPayloadSchema = targetRefSchema.extend({
+  claimId: import_zod3.z.string(),
+  action: import_zod3.z.string(),
+  /** Hint for `expiresAt`; the server caps it. */
+  estimatedMs: import_zod3.z.number().optional(),
+  /**
+   * Opt into the fair wait queue: when the target is already held, the server
+   * enqueues this claim (FIFO) and replies `claim_queued` → later
+   * `claim_granted`, instead of `claim_rejected`. Clients that set this MUST
+   * handle the grant.
+   */
+  queue: import_zod3.z.boolean().optional()
+});
+var claimAbandonPayloadSchema = import_zod3.z.object({
+  claimId: import_zod3.z.string(),
+  entityType: import_zod3.z.string().optional(),
+  entityId: import_zod3.z.string().optional()
+});
+var claimReorderPayloadSchema = import_zod3.z.object({
+  entityType: import_zod3.z.string(),
+  entityId: import_zod3.z.string(),
+  order: import_zod3.z.array(import_zod3.z.object({ heldBy: import_zod3.z.string(), claimId: import_zod3.z.string() }))
+});
+var updateSubscriptionPayloadSchema = import_zod3.z.object({
+  syncGroups: import_zod3.z.array(syncGroupInputSchema)
+});
+var subscriptionAckPayloadSchema = import_zod3.z.object({
+  success: import_zod3.z.boolean(),
+  syncGroups: import_zod3.z.array(import_zod3.z.string()),
+  error: import_zod3.z.object({ code: import_zod3.z.string(), message: import_zod3.z.string() }).optional()
+});
+var commitOperationTypeSchema = import_zod3.z.enum([
+  "CREATE",
+  "UPDATE",
+  "DELETE",
+  "ARCHIVE",
+  "UNARCHIVE"
+]);
+var commitOperationSchema = writeGuardSchema.extend({
+  type: commitOperationTypeSchema,
+  model: import_zod3.z.string(),
+  id: import_zod3.z.string().nullish(),
+  input: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).nullish(),
+  /** Per-op client tx id, echoed on the broadcast delta. */
+  transactionId: import_zod3.z.string().nullish()
+});
+var presenceKindSchema = import_zod3.z.enum(["enter", "update", "leave"]);
+var presenceActivitySchema = targetRefSchema.extend({
+  action: import_zod3.z.string(),
+  detail: import_zod3.z.string().optional()
+});
+var presenceUpdateFrameSchema = import_zod3.z.object({
+  kind: presenceKindSchema,
+  userId: import_zod3.z.string().optional(),
+  syncGroups: import_zod3.z.array(import_zod3.z.string()).optional(),
+  timestamp: import_zod3.z.number().optional(),
+  status: import_zod3.z.string(),
+  timezone: import_zod3.z.string().optional(),
+  customStatus: import_zod3.z.string().optional(),
+  activity: presenceActivitySchema.optional(),
+  isAgent: import_zod3.z.boolean().optional(),
+  /**
+   * Server-stamped canonical kind. Additive — older servers omit it and
+   * readers fall back to `isAgent` (see {@link participantKindFromWire}).
+   */
+  participantKind: wireParticipantKindSchema.optional(),
+  activeClaims: import_zod3.z.array(wireClaimSchema).optional(),
+  delegatedFrom: import_zod3.z.string().nullish()
+});
+
 // src/errors.ts
 var AbloError = class extends Error {
   /** Discriminator string — matches the class name. Lets consumers
@@ -277068,35 +277266,43 @@ function docUrlForCode(code) {
 var AbloValidationError = class extends AbloError {
   type = "AbloValidationError";
 };
-var OptionalWireStringSchema = import_zod2.z.preprocess(
+var OptionalWireStringSchema = import_zod4.z.preprocess(
   (value) => typeof value === "string" ? value : void 0,
-  import_zod2.z.string().optional()
+  import_zod4.z.string().optional()
 );
-var RequiredCapabilityWireSchema = import_zod2.z.object({
-  scope: import_zod2.z.string(),
-  constraints: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.string()])).optional(),
+var RequiredCapabilityWireSchema = import_zod4.z.object({
+  scope: import_zod4.z.string(),
+  constraints: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.union([import_zod4.z.array(import_zod4.z.string()), import_zod4.z.string()])).optional(),
   issuer: OptionalWireStringSchema,
-  ttlSeconds: import_zod2.z.preprocess((value) => typeof value === "number" ? value : void 0, import_zod2.z.number().optional()),
+  ttlSeconds: import_zod4.z.preprocess((value) => typeof value === "number" ? value : void 0, import_zod4.z.number().optional()),
   nonce: OptionalWireStringSchema
 }).passthrough();
-var NestedErrorShapeSchema = import_zod2.z.object({
+var NestedErrorShapeSchema = import_zod4.z.object({
   code: OptionalWireStringSchema,
   message: OptionalWireStringSchema,
   field: OptionalWireStringSchema,
-  requiredCapability: RequiredCapabilityWireSchema.optional().catch(void 0)
+  requiredCapability: RequiredCapabilityWireSchema.optional().catch(void 0),
+  heldBy: OptionalWireStringSchema,
+  policyReason: OptionalWireStringSchema,
+  heldByClaim: wireClaimSummarySchema.optional().catch(void 0),
+  claims: import_zod4.z.array(wireClaimSummarySchema).optional().catch(void 0)
 }).passthrough();
-var ErrorFieldSchema = import_zod2.z.preprocess(
+var ErrorFieldSchema = import_zod4.z.preprocess(
   (value) => typeof value === "string" || typeof value === "object" && value !== null ? value : void 0,
-  import_zod2.z.union([import_zod2.z.string(), NestedErrorShapeSchema]).optional()
+  import_zod4.z.union([import_zod4.z.string(), NestedErrorShapeSchema]).optional()
 ).catch(void 0);
-var ErrorBodyShapeSchema = import_zod2.z.object({
+var ErrorBodyShapeSchema = import_zod4.z.object({
   /** Legacy: `error` was a flat code string on older endpoints. Newer
    *  endpoints (CommitReceipt) carry `error` as a nested object. */
   error: ErrorFieldSchema,
   code: OptionalWireStringSchema,
   reason: OptionalWireStringSchema,
   message: OptionalWireStringSchema,
-  requiredCapability: RequiredCapabilityWireSchema.optional().catch(void 0)
+  requiredCapability: RequiredCapabilityWireSchema.optional().catch(void 0),
+  heldBy: OptionalWireStringSchema,
+  policyReason: OptionalWireStringSchema,
+  heldByClaim: wireClaimSummarySchema.optional().catch(void 0),
+  claims: import_zod4.z.array(wireClaimSummarySchema).optional().catch(void 0)
 }).passthrough();
 
 // src/cli/migrate.ts
@@ -279404,7 +279610,7 @@ function readProjectDatabaseUrl(cwd = process.cwd()) {
 }
 
 // src/cli/migrate.ts
-var import_schema2 = require("@abloatai/ablo/schema");
+var import_schema3 = require("@abloatai/ablo/schema");
 var import_source = require("@abloatai/ablo/source");
 
 // src/cli/push.ts
@@ -279412,7 +279618,7 @@ init_cjs_shims();
 var import_picocolors3 = __toESM(require_picocolors(), 1);
 var import_fs4 = require("fs");
 var import_path3 = require("path");
-var import_schema = require("@abloatai/ablo/schema");
+var import_schema2 = require("@abloatai/ablo/schema");
 
 // src/cli/config.ts
 init_cjs_shims();
@@ -279577,7 +279783,7 @@ function fmtSignal(s) {
   return `    \u2022 ${import_picocolors3.default.bold(where ?? "?")} \u2014 ${sig.detail ?? ""}`;
 }
 async function pushSchema(schema, args) {
-  const schemaJson = JSON.parse((0, import_schema.serializeSchema)(schema));
+  const schemaJson = JSON.parse((0, import_schema2.serializeSchema)(schema));
   const res = await fetch(`${args.url}/api/schema`, {
     method: "POST",
     headers: {
@@ -279690,7 +279896,7 @@ async function push(argv) {
     process.exit(1);
   }
   const schema = await loadSchema(args.schemaPath, args.exportName);
-  const hash = (0, import_schema.schemaHash)(schema);
+  const hash = (0, import_schema2.schemaHash)(schema);
   console.log(
     `  Pushing ${import_picocolors3.default.bold(args.schemaPath)} ${import_picocolors3.default.dim(`(${Object.keys(schema.models).length} models, hash ${hash})`)} \u2192 ${import_picocolors3.default.dim(args.url)}`
   );
@@ -279769,8 +279975,8 @@ function parseMigrateArgs(argv) {
   return { schemaPath, exportName, targetSchema, dryRun, outputFile };
 }
 function planFor(schema, targetSchema = "public") {
-  const schemaJson = JSON.parse((0, import_schema2.serializeSchema)(schema));
-  const plan = (0, import_schema2.generateProvisionPlan)(schemaJson, targetSchema, {
+  const schemaJson = JSON.parse((0, import_schema3.serializeSchema)(schema));
+  const plan = (0, import_schema3.generateProvisionPlan)(schemaJson, targetSchema, {
     foreignKeys: targetSchema === "public"
   });
   const adapterTables = (0, import_source.adapterTableMigrations)().map((m2) => m2.up);
@@ -279895,7 +280101,7 @@ init_cjs_shims();
 var import_fs6 = require("fs");
 var import_path4 = require("path");
 var import_picocolors5 = __toESM(require_picocolors(), 1);
-var import_schema3 = require("@abloatai/ablo/schema");
+var import_schema4 = require("@abloatai/ablo/schema");
 var DEFAULT_SCHEMA_PATH3 = "ablo/schema.ts";
 var DEFAULT_EXPORT3 = "schema";
 var DEFAULT_OUT = "ablo/generated.ts";
@@ -279932,8 +280138,8 @@ async function generate(argv) {
   let source;
   try {
     const schema = await loadSchema(args.schemaPath, args.exportName);
-    const schemaJson = JSON.parse((0, import_schema3.serializeSchema)(schema));
-    source = (0, import_schema3.generateTypes)(schemaJson);
+    const schemaJson = JSON.parse((0, import_schema4.serializeSchema)(schema));
+    source = (0, import_schema4.generateTypes)(schemaJson);
   } catch (err) {
     console.error(import_picocolors5.default.red(`  ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
@@ -279949,7 +280155,7 @@ init_cjs_shims();
 var import_picocolors6 = __toESM(require_picocolors(), 1);
 var import_fs7 = require("fs");
 var import_path5 = require("path");
-var import_schema4 = require("@abloatai/ablo/schema");
+var import_schema5 = require("@abloatai/ablo/schema");
 
 // src/cli/theme.ts
 init_cjs_shims();
@@ -280115,7 +280321,7 @@ async function dev(argv) {
   const schema = await loadSchema(args.schemaPath, args.exportName);
   const modelCount = Object.keys(schema.models).length;
   console.log(
-    `  ${import_picocolors6.default.dim("schema")}  ${import_picocolors6.default.bold(args.schemaPath)} ${import_picocolors6.default.dim(`(${modelCount} models, hash ${(0, import_schema4.schemaHash)(schema)})`)}`
+    `  ${import_picocolors6.default.dim("schema")}  ${import_picocolors6.default.bold(args.schemaPath)} ${import_picocolors6.default.dim(`(${modelCount} models, hash ${(0, import_schema5.schemaHash)(schema)})`)}`
   );
   console.log(`  ${import_picocolors6.default.dim("key")}     ${args.apiKey.slice(0, 12)}\u2026`);
   console.log(`  ${import_picocolors6.default.dim("api")}     ${args.url}
@@ -280937,7 +281143,7 @@ async function webhooks(argv) {
 // src/cli/check.ts
 init_cjs_shims();
 var import_picocolors13 = __toESM(require_picocolors(), 1);
-var import_schema5 = require("@abloatai/ablo/schema");
+var import_schema6 = require("@abloatai/ablo/schema");
 var DEFAULT_SCHEMA_PATH4 = "ablo/schema.ts";
 var DEFAULT_EXPORT4 = "schema";
 var BASE_COLUMNS = /* @__PURE__ */ new Set(["id", "organization_id", "created_by", "created_at", "updated_at"]);
@@ -280982,7 +281188,7 @@ async function check(argv) {
     process.exit(1);
   }
   const schema = await loadSchema(args.schemaPath, args.exportName);
-  const schemaJson = JSON.parse((0, import_schema5.serializeSchema)(schema));
+  const schemaJson = JSON.parse((0, import_schema6.serializeSchema)(schema));
   const sql = src_default(dbUrl, { max: 1, prepare: false, onnotice: () => {
   } });
   let rows;
@@ -281024,7 +281230,7 @@ async function check(argv) {
     const problems = [];
     const warns = [];
     if (!present.has("id")) problems.push('missing primary key "id"');
-    const orgCol = (0, import_schema5.tenancyColumn)((0, import_schema5.resolveTenancy)(model));
+    const orgCol = (0, import_schema6.tenancyColumn)((0, import_schema6.resolveTenancy)(model));
     if (orgCol && !present.has(orgCol)) {
       problems.push(
         `missing "${orgCol}" \u2014 Ablo isolates tenants (RLS) and routes realtime by it, so a table without it has no safe boundary. Add the column, or use a Data Source endpoint.`
@@ -281202,8 +281408,8 @@ async function upgrade(argv) {
       if (t === "drizzleDataSource" && call.getArguments().length === 2 && !import_ts_morph.Node.isIdentifier(call.getArguments()[1])) {
         flag2(call, "drizzleDataSource(db, tables)", "now `drizzleDataSource(db, schema)` \u2014 pass your Ablo schema, drop the tables map.");
       }
-      if (/\.intents\b/.test(t) && /^(ablo|sync)\b/.test(t)) {
-        flag2(call, "ablo.intents.*", "use `ablo.<model>.claim` (claim.state / claim.queue / `await using claim = await \u2026claim({ id })`).");
+      if (/\.claims\b/.test(t) && /^(ablo|sync)\b/.test(t)) {
+        flag2(call, "ablo.claims.*", "use `ablo.<model>.claim` (claim.state / claim.queue / `await using claim = await \u2026claim({ id })`).");
       }
     }
     for (const jsx of sf.getDescendantsOfKind(import_ts_morph.SyntaxKind.JsxOpeningElement)) {