@abloatai/transaction 0.37.0

package/dist/resources/where.js

@@ -0,0 +1,116 @@
+/**
+ * The where-clause grammar carried by a filtered read.
+ *
+ * A `where` is a flat list of `[column, operator, value]` conditions combined
+ * with AND. The protocol carries no model-specific logic: the server compiles a
+ * condition against your schema, so adding a model or relation is a schema
+ * change rather than a server change.
+ *
+ * The `IN` operator lets you batch a read by any column, including a foreign
+ * key — for example, fetching every block whose `sectionId` falls in a set of ids.
+ *
+ * These types describe the *request*, not any local copy of the rows it returns,
+ * so they live with the settlement core rather than the reactive consumer.
+ */
+import { z } from 'zod';
+import { AbloValidationError } from '../errors.js';
+/**
+ * The comparison operators a {@link WhereClause} may use: equality and
+ * inequality, ordering, set membership (`IN` / `NOT IN`), null checks
+ * (`IS` / `IS NOT`), and case-sensitive or case-insensitive pattern
+ * matching (`LIKE`, `ILIKE`, and their negations).
+ */
+export const whereOpSchema = z.enum([
+    '=',
+    '!=',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    'IN',
+    'NOT IN',
+    'IS',
+    'IS NOT',
+    'LIKE',
+    'NOT LIKE',
+    'ILIKE',
+    'NOT ILIKE',
+]);
+/**
+ * How each operator binds its operand — the classification a compiler needs
+ * before it can render or evaluate a condition: a scalar on the right, an array
+ * to expand, or a null check with no operand at all. `LIKE_OPS` is the subset
+ * whose operand is a pattern and therefore needs pattern validation.
+ *
+ * These live here, beside the operators, because every consumer of the grammar
+ * needs the same split and there is more than one consumer: a where clause is
+ * compiled to SQL on a hosted plane and evaluated in memory against the log on
+ * a source plane. Two hand-maintained copies of this split meant the same
+ * request could be accepted by one plane and rejected by the other — and the
+ * pattern-safety set existed on only one of them.
+ */
+export const WHERE_SCALAR_OPS = new Set([
+    '=',
+    '!=',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    'LIKE',
+    'NOT LIKE',
+    'ILIKE',
+    'NOT ILIKE',
+]);
+export const WHERE_ARRAY_OPS = new Set(['IN', 'NOT IN']);
+export const WHERE_NULL_OPS = new Set(['IS', 'IS NOT']);
+export const WHERE_LIKE_OPS = new Set([
+    'LIKE',
+    'NOT LIKE',
+    'ILIKE',
+    'NOT ILIKE',
+]);
+/**
+ * Does this operator accept this operand? The rule the sets above imply, stated
+ * once and thrown once.
+ *
+ * The sets were collapsed here because two copies of the split let one plane
+ * accept a request the other refused. The check that consumes them stayed
+ * duplicated — the SQL compiler and the log-plane evaluator each carried their
+ * own arity tests and their own wording — which leaves the same gap one step
+ * further along: relax `IN` in one evaluator and a request succeeds against a
+ * hosted plane and fails against a connected one, with no test in a position to
+ * notice.
+ *
+ * Returns the classification the caller needs next, so the check and the branch
+ * are the same statement rather than two that can disagree.
+ */
+export function classifyWhereOperand(op, value) {
+    if (WHERE_NULL_OPS.has(op)) {
+        if (value !== null) {
+            throw new AbloValidationError(`${op} only supports null RHS`, {
+                code: 'query_unsupported_operator',
+            });
+        }
+        return 'null';
+    }
+    if (WHERE_ARRAY_OPS.has(op)) {
+        if (!Array.isArray(value)) {
+            throw new AbloValidationError(`${op} requires an array RHS`, {
+                code: 'query_unsupported_operator',
+            });
+        }
+        return 'array';
+    }
+    if (WHERE_SCALAR_OPS.has(op)) {
+        if (Array.isArray(value)) {
+            throw new AbloValidationError(`${op} requires a scalar RHS`, {
+                code: 'query_unsupported_operator',
+            });
+        }
+        return 'scalar';
+    }
+    throw new AbloValidationError(`unsupported operator: ${op}`, {
+        code: 'query_unsupported_operator',
+    });
+}
+//# sourceMappingURL=where.js.map

package/dist/resources/where.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"where.js","sourceRoot":"","sources":["../../src/resources/where.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAKnD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC;IAClC,GAAG;IACH,IAAI;IACJ,GAAG;IACH,IAAI;IACJ,GAAG;IACH,IAAI;IACJ,IAAI;IACJ,QAAQ;IACR,IAAI;IACJ,QAAQ;IACR,MAAM;IACN,UAAU;IACV,OAAO;IACP,WAAW;CACZ,CAAC,CAAC;AAGH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAyB,IAAI,GAAG,CAAU;IACrE,GAAG;IACH,IAAI;IACJ,GAAG;IACH,IAAI;IACJ,GAAG;IACH,IAAI;IACJ,MAAM;IACN,UAAU;IACV,OAAO;IACP,WAAW;CACZ,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,eAAe,GAAyB,IAAI,GAAG,CAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;AACxF,MAAM,CAAC,MAAM,cAAc,GAAyB,IAAI,GAAG,CAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;AACvF,MAAM,CAAC,MAAM,cAAc,GAAyB,IAAI,GAAG,CAAU;IACnE,MAAM;IACN,UAAU;IACV,OAAO;IACP,WAAW;CACZ,CAAC,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,oBAAoB,CAClC,EAAW,EACX,KAAc;IAEd,IAAI,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;QAC3B,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,MAAM,IAAI,mBAAmB,CAAC,GAAG,EAAE,yBAAyB,EAAE;gBAC5D,IAAI,EAAE,4BAA4B;aACnC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,IAAI,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;QAC5B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,mBAAmB,CAAC,GAAG,EAAE,wBAAwB,EAAE;gBAC3D,IAAI,EAAE,4BAA4B;aACnC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,IAAI,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;QAC7B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,mBAAmB,CAAC,GAAG,EAAE,wBAAwB,EAAE;gBAC3D,IAAI,EAAE,4BAA4B;aACnC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,MAAM,IAAI,mBAAmB,CAAC,yBAAyB,EAAE,EAAE,EAAE;QAC3D,IAAI,EAAE,4BAA4B;KACnC,CAAC,CAAC;AACL,CAAC"}

package/dist/resources/writeOptionsSchema.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The Zod schema for write options — the settings accepted by every write
+ * entry point, including `ablo.<model>.create/update/delete`, `commits.create`,
+ * and the HTTP write routes. Each of those boundaries validates against this
+ * one schema, so a caller who passes, say, `onStale: 'rejct'` fails right away
+ * with a typed {@link AbloValidationError} at the call site instead of silently
+ * or with a 400 from the server.
+ *
+ * The schema is the runtime counterpart of the {@link MutationOptions}
+ * interface. A compile-time check at the bottom of this file asserts that the
+ * two describe the same shape, so they cannot drift apart.
+ *
+ * Validation only inspects; it never transforms. Callers keep the exact options
+ * object they passed in. This matters because the `claim` field can hold a live
+ * claim handle whose `release` and `revoke` functions must survive, so the code
+ * asserts the shape rather than replacing the value with a parsed copy.
+ */
+import { z } from 'zod';
+import { onStaleModeSchema } from '../coordination/schema.js';
+export { onStaleModeSchema };
+export declare const writeOptionsSchema: z.ZodObject<{
+    idempotencyKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    label: z.ZodOptional<z.ZodString>;
+    wait: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        confirmed: "confirmed";
+    }>>;
+    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>>;
+    fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    claim: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$loose>]>>>;
+}, z.core.$strip>;
+export type WriteOptionsInput = z.infer<typeof writeOptionsSchema>;
+/**
+ * Validates a write-options object against {@link writeOptionsSchema}. On
+ * failure it throws a typed {@link AbloValidationError} — with
+ * `code: 'write_options_invalid'` and a `param` pointing at the offending
+ * field — and on success returns nothing, leaving the caller's original object
+ * untouched. A `null` or `undefined` value passes.
+ */
+export declare function assertWriteOptions(value: unknown, context?: string): void;
+//# sourceMappingURL=writeOptionsSchema.d.ts.map

package/dist/resources/writeOptionsSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeOptionsSchema.d.ts","sourceRoot":"","sources":["../../src/resources/writeOptionsSchema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAO9D,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAE7B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAoB7B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEnE;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAezE"}

package/dist/resources/writeOptionsSchema.js

@@ -0,0 +1,74 @@
+/**
+ * The Zod schema for write options — the settings accepted by every write
+ * entry point, including `ablo.<model>.create/update/delete`, `commits.create`,
+ * and the HTTP write routes. Each of those boundaries validates against this
+ * one schema, so a caller who passes, say, `onStale: 'rejct'` fails right away
+ * with a typed {@link AbloValidationError} at the call site instead of silently
+ * or with a 400 from the server.
+ *
+ * The schema is the runtime counterpart of the {@link MutationOptions}
+ * interface. A compile-time check at the bottom of this file asserts that the
+ * two describe the same shape, so they cannot drift apart.
+ *
+ * Validation only inspects; it never transforms. Callers keep the exact options
+ * object they passed in. This matters because the `claim` field can hold a live
+ * claim handle whose `release` and `revoke` functions must survive, so the code
+ * asserts the shape rather than replacing the value with a parsed copy.
+ */
+import { z } from 'zod';
+import { AbloValidationError } from '../errors.js';
+import { commitWaitSchema } from '../wire/commit.js';
+import { onStaleModeSchema } from '../coordination/schema.js';
+// Re-exported, not redeclared. `coordination/schema.ts` owns this enum — it is
+// what the wire schemas and the server validate against — while the published
+// SDK barrel exports the name from this module. Declaring it twice put a second
+// object behind the public export that agreed with the canonical one only by
+// both happening to list the same three strings.
+export { onStaleModeSchema };
+export const writeOptionsSchema = z.object({
+    /** Idempotency key the server records in `mutation_log` to make retries
+     *  safe; `null` opts out of that protection. */
+    idempotencyKey: z.string().min(1).max(255).nullish(),
+    /** Human-readable audit tag, persisted to `mutation_log.label`. */
+    label: z.string().max(255).optional(),
+    /** Resolve when queued locally (default) or once the server confirms. */
+    wait: commitWaitSchema.optional(),
+    /** Stale guard: the sync watermark the caller's reasoning was based on. */
+    readAt: z.number().int().nonnegative().nullish(),
+    /** What the server does when the target moved past `readAt`. */
+    onStale: onStaleModeSchema.nullish(),
+    /** The held claim's fencing token (Option B), sourced from the claim handle
+     *  rather than set by hand; the server validates it against the entity's
+     *  high-water. Kept in the schema so it stays aligned with `MutationOptions`
+     *  (the drift guard below) and a malformed token is rejected at the boundary. */
+    fenceToken: z.number().nullish(),
+    /** The claim this write belongs to — either a claim id, or a live claim
+     *  handle whose `release`/`revoke` functions are preserved untouched. */
+    claim: z.union([z.string(), z.looseObject({ id: z.string() })]).nullish(),
+});
+/**
+ * Validates a write-options object against {@link writeOptionsSchema}. On
+ * failure it throws a typed {@link AbloValidationError} — with
+ * `code: 'write_options_invalid'` and a `param` pointing at the offending
+ * field — and on success returns nothing, leaving the caller's original object
+ * untouched. A `null` or `undefined` value passes.
+ */
+export function assertWriteOptions(value, context) {
+    if (value == null)
+        return;
+    const result = writeOptionsSchema.safeParse(value);
+    if (result.success)
+        return;
+    const issue = result.error.issues[0];
+    const path = issue?.path.map(String).join('.') ?? '';
+    throw new AbloValidationError(`Invalid write options${context ? ` on \`${context}\`` : ''}${path ? ` at \`${path}\`` : ''}: ${issue?.message ?? 'failed validation'}.`, {
+        code: 'write_options_invalid',
+        ...(path ? { param: path } : {}),
+    });
+}
+const _writeOptionsContractInSync = [
+    true,
+    true,
+];
+void _writeOptionsContractInSync;
+//# sourceMappingURL=writeOptionsSchema.js.map

package/dist/resources/writeOptionsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeOptionsSchema.js","sourceRoot":"","sources":["../../src/resources/writeOptionsSchema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,+EAA+E;AAC/E,8EAA8E;AAC9E,gFAAgF;AAChF,6EAA6E;AAC7E,iDAAiD;AACjD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAE7B,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC;oDACgD;IAChD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE;IACpD,mEAAmE;IACnE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE;IACrC,yEAAyE;IACzE,IAAI,EAAE,gBAAgB,CAAC,QAAQ,EAAE;IACjC,2EAA2E;IAC3E,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE;IAChD,gEAAgE;IAChE,OAAO,EAAE,iBAAiB,CAAC,OAAO,EAAE;IACpC;;;qFAGiF;IACjF,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE;IAChC;6EACyE;IACzE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE;CAC1E,CAAC,CAAC;AAIH;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAc,EAAE,OAAgB;IACjE,IAAI,KAAK,IAAI,IAAI;QAAE,OAAO;IAC1B,MAAM,MAAM,GAAG,kBAAkB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACnD,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO;IAC3B,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACrC,MAAM,IAAI,GAAG,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;IACrD,MAAM,IAAI,mBAAmB,CAC3B,wBAAwB,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,GACzD,IAAI,CAAC,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC,CAAC,EAC7B,KAAK,KAAK,EAAE,OAAO,IAAI,mBAAmB,GAAG,EAC7C;QACE,IAAI,EAAE,uBAAuB;QAC7B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACjC,CACF,CAAC;AACJ,CAAC;AASD,MAAM,2BAA2B,GAA6D;IAC5F,IAAI;IACJ,IAAI;CACL,CAAC;AACF,KAAK,2BAA2B,CAAC"}

package/dist/schema/coordination.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Authoring helpers for a model's `conflict` axis — the setting that decides
+ * what happens when two writers touch the same row. Instead of writing a raw
+ * disposition map, you name the rules the way the rest of the schema DSL reads
+ * (`relation.belongsTo()`, `field.string()`), and chain them the way a field
+ * chains its own modifiers:
+ *
+ * ```ts
+ * import { coordination } from '@abloatai/transaction/schema';
+ *
+ * conflict: coordination.humansOverwrite().agentsReject()
+ * // → { user: 'overwrite', agent: 'reject' }  (a human's write wins, an agent's yields)
+ * ```
+ *
+ * Each rule is named for the disposition it applies — drawn from the same
+ * `overwrite | reject | notify` vocabulary the write guards use (`onStale`) —
+ * and every one of them is also available as a standalone function, which
+ * {@link coordination} merges when the rules are assembled dynamically rather
+ * than written out:
+ *
+ * ```ts
+ * conflict: coordination(humansOverwrite(), agentsReject())
+ * ```
+ *
+ * Either way the result is plain, serializable data that the engine reads at
+ * commit time. The `humans`/`agents` wording belongs to the author; the `user`/
+ * `agent`/`system` keys belong to the wire, and this module is the one place
+ * the two are mapped to each other.
+ */
+import type { ConflictAxis } from '../policy/types.js';
+/**
+ * One coordination rule: a partial {@link ConflictAxis} produced by a
+ * disposition helper below. Compose with {@link coordination}.
+ */
+export type ConflictRule = ConflictAxis;
+/** A human's conflicting write wins and overwrites the other; it is never blocked. Among humans this gives last-write-wins. */
+export declare const humansOverwrite: () => ConflictRule;
+/** A human's conflicting write is rejected, yielding to a held claim or a stale snapshot. */
+export declare const humansReject: () => ConflictRule;
+/** A human's stale write triggers a notification: it re-reads and re-applies rather than clobbering. */
+export declare const humansNotify: () => ConflictRule;
+/** An agent's conflicting write wins and overwrites the other (rarely what you want). */
+export declare const agentsOverwrite: () => ConflictRule;
+/** An agent's conflicting write is rejected, yielding to a held claim or a stale snapshot. */
+export declare const agentsReject: () => ConflictRule;
+/** An agent's stale write triggers a notification: it re-reads and re-applies rather than clobbering. */
+export declare const agentsNotify: () => ConflictRule;
+/** A system or automation write wins and overwrites the other. */
+export declare const systemOverwrite: () => ConflictRule;
+/** A system or automation write is rejected. */
+export declare const systemReject: () => ConflictRule;
+/** A system or automation stale write triggers a notification: it re-reads and re-applies. */
+export declare const systemNotify: () => ConflictRule;
+/**
+ * A conflict axis that is still open to more rules. Every method applies one
+ * disposition and hands back a new axis, so a model's whole stance reads as a
+ * single sentence and the reader never has to hold a merge in their head.
+ *
+ * Each method delegates to the standalone rule of the same name, so a
+ * disposition map like `{ user: 'overwrite' }` is written in exactly one place
+ * no matter which authoring style a schema uses. Dispositions are own
+ * enumerable properties and the methods live on the prototype, so an axis
+ * serializes to the same plain object the server has always received.
+ */
+declare class CoordinationAxis implements ConflictAxis {
+    readonly user?: ConflictAxis['user'];
+    readonly agent?: ConflictAxis['agent'];
+    readonly system?: ConflictAxis['system'];
+    constructor(axis: ConflictAxis);
+    /** Apply one more rule, later winning on a repeated kind. */
+    private and;
+    humansOverwrite(): CoordinationAxis;
+    humansReject(): CoordinationAxis;
+    humansNotify(): CoordinationAxis;
+    agentsOverwrite(): CoordinationAxis;
+    agentsReject(): CoordinationAxis;
+    agentsNotify(): CoordinationAxis;
+    systemOverwrite(): CoordinationAxis;
+    systemReject(): CoordinationAxis;
+    systemNotify(): CoordinationAxis;
+}
+/**
+ * Merges coordination rules into a single {@link ConflictAxis}. Later rules win
+ * on key collisions, and a committer kind you leave out falls through to the
+ * engine's default at commit time.
+ *
+ * ```ts
+ * coordination(humansOverwrite(), agentsReject())  // → { user: 'overwrite', agent: 'reject' }
+ * ```
+ */
+declare function mergeRules(...rules: readonly ConflictRule[]): ConflictAxis;
+/**
+ * The coordination vocabulary, reachable through one name. Call it to merge
+ * rules you have assembled; reach through it to start a chain.
+ *
+ * ```ts
+ * conflict: coordination.humansOverwrite().agentsReject()
+ * conflict: coordination(humansOverwrite(), agentsReject())
+ * ```
+ */
+export declare const coordination: typeof mergeRules & {
+    humansOverwrite: () => CoordinationAxis;
+    humansReject: () => CoordinationAxis;
+    humansNotify: () => CoordinationAxis;
+    agentsOverwrite: () => CoordinationAxis;
+    agentsReject: () => CoordinationAxis;
+    agentsNotify: () => CoordinationAxis;
+    systemOverwrite: () => CoordinationAxis;
+    systemReject: () => CoordinationAxis;
+    systemNotify: () => CoordinationAxis;
+};
+export {};
+//# sourceMappingURL=coordination.d.ts.map

package/dist/schema/coordination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordination.d.ts","sourceRoot":"","sources":["../../src/schema/coordination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,CAAC;AAGxC,+HAA+H;AAC/H,eAAO,MAAM,eAAe,QAAO,YAAuC,CAAC;AAC3E,6FAA6F;AAC7F,eAAO,MAAM,YAAY,QAAO,YAAoC,CAAC;AACrE,wGAAwG;AACxG,eAAO,MAAM,YAAY,QAAO,YAAoC,CAAC;AAGrE,yFAAyF;AACzF,eAAO,MAAM,eAAe,QAAO,YAAwC,CAAC;AAC5E,8FAA8F;AAC9F,eAAO,MAAM,YAAY,QAAO,YAAqC,CAAC;AACtE,yGAAyG;AACzG,eAAO,MAAM,YAAY,QAAO,YAAqC,CAAC;AAGtE,kEAAkE;AAClE,eAAO,MAAM,eAAe,QAAO,YAAyC,CAAC;AAC7E,gDAAgD;AAChD,eAAO,MAAM,YAAY,QAAO,YAAsC,CAAC;AACvE,8FAA8F;AAC9F,eAAO,MAAM,YAAY,QAAO,YAAsC,CAAC;AAEvE;;;;;;;;;;GAUG;AACH,cAAM,gBAAiB,YAAW,YAAY;IAM5C,SAAiB,IAAI,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAC7C,SAAiB,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAC/C,SAAiB,MAAM,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;gBAErC,IAAI,EAAE,YAAY;IAO9B,6DAA6D;IAC7D,OAAO,CAAC,GAAG;IAQX,eAAe,IAAI,gBAAgB;IAGnC,YAAY,IAAI,gBAAgB;IAGhC,YAAY,IAAI,gBAAgB;IAGhC,eAAe,IAAI,gBAAgB;IAGnC,YAAY,IAAI,gBAAgB;IAGhC,YAAY,IAAI,gBAAgB;IAGhC,eAAe,IAAI,gBAAgB;IAGnC,YAAY,IAAI,gBAAgB;IAGhC,YAAY,IAAI,gBAAgB;CAGjC;AAED;;;;;;;;GAQG;AACH,iBAAS,UAAU,CAAC,GAAG,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CAEnE;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;2BACF,gBAAgB;wBACnB,gBAAgB;wBAChB,gBAAgB;2BACb,gBAAgB;wBACnB,gBAAgB;wBAChB,gBAAgB;2BACb,gBAAgB;wBACnB,gBAAgB;wBAChB,gBAAgB;CAClC,CAAC"}

package/dist/schema/coordination.js

@@ -0,0 +1,134 @@
+/**
+ * Authoring helpers for a model's `conflict` axis — the setting that decides
+ * what happens when two writers touch the same row. Instead of writing a raw
+ * disposition map, you name the rules the way the rest of the schema DSL reads
+ * (`relation.belongsTo()`, `field.string()`), and chain them the way a field
+ * chains its own modifiers:
+ *
+ * ```ts
+ * import { coordination } from '@abloatai/transaction/schema';
+ *
+ * conflict: coordination.humansOverwrite().agentsReject()
+ * // → { user: 'overwrite', agent: 'reject' }  (a human's write wins, an agent's yields)
+ * ```
+ *
+ * Each rule is named for the disposition it applies — drawn from the same
+ * `overwrite | reject | notify` vocabulary the write guards use (`onStale`) —
+ * and every one of them is also available as a standalone function, which
+ * {@link coordination} merges when the rules are assembled dynamically rather
+ * than written out:
+ *
+ * ```ts
+ * conflict: coordination(humansOverwrite(), agentsReject())
+ * ```
+ *
+ * Either way the result is plain, serializable data that the engine reads at
+ * commit time. The `humans`/`agents` wording belongs to the author; the `user`/
+ * `agent`/`system` keys belong to the wire, and this module is the one place
+ * the two are mapped to each other.
+ */
+// ── Humans (user sessions) ──────────────────────────────────────────────
+/** A human's conflicting write wins and overwrites the other; it is never blocked. Among humans this gives last-write-wins. */
+export const humansOverwrite = () => ({ user: 'overwrite' });
+/** A human's conflicting write is rejected, yielding to a held claim or a stale snapshot. */
+export const humansReject = () => ({ user: 'reject' });
+/** A human's stale write triggers a notification: it re-reads and re-applies rather than clobbering. */
+export const humansNotify = () => ({ user: 'notify' });
+// ── Agents (AI) ─────────────────────────────────────────────────────────
+/** An agent's conflicting write wins and overwrites the other (rarely what you want). */
+export const agentsOverwrite = () => ({ agent: 'overwrite' });
+/** An agent's conflicting write is rejected, yielding to a held claim or a stale snapshot. */
+export const agentsReject = () => ({ agent: 'reject' });
+/** An agent's stale write triggers a notification: it re-reads and re-applies rather than clobbering. */
+export const agentsNotify = () => ({ agent: 'notify' });
+// ── System / automation ─────────────────────────────────────────────────
+/** A system or automation write wins and overwrites the other. */
+export const systemOverwrite = () => ({ system: 'overwrite' });
+/** A system or automation write is rejected. */
+export const systemReject = () => ({ system: 'reject' });
+/** A system or automation stale write triggers a notification: it re-reads and re-applies. */
+export const systemNotify = () => ({ system: 'notify' });
+/**
+ * A conflict axis that is still open to more rules. Every method applies one
+ * disposition and hands back a new axis, so a model's whole stance reads as a
+ * single sentence and the reader never has to hold a merge in their head.
+ *
+ * Each method delegates to the standalone rule of the same name, so a
+ * disposition map like `{ user: 'overwrite' }` is written in exactly one place
+ * no matter which authoring style a schema uses. Dispositions are own
+ * enumerable properties and the methods live on the prototype, so an axis
+ * serializes to the same plain object the server has always received.
+ */
+class CoordinationAxis {
+    constructor(axis) {
+        Object.assign(this, Object.fromEntries(Object.entries(axis).filter(([, mode]) => mode !== undefined)));
+    }
+    /** Apply one more rule, later winning on a repeated kind. */
+    and(rule) {
+        // Assigned rather than spread, and for the reason the merge form below
+        // assigns too: what carries forward is the dispositions, which are own
+        // enumerable properties. The chaining methods live on the prototype and the
+        // constructor puts them back, so a chain accumulates nothing but data.
+        return new CoordinationAxis(Object.assign({}, this, rule));
+    }
+    humansOverwrite() {
+        return this.and(humansOverwrite());
+    }
+    humansReject() {
+        return this.and(humansReject());
+    }
+    humansNotify() {
+        return this.and(humansNotify());
+    }
+    agentsOverwrite() {
+        return this.and(agentsOverwrite());
+    }
+    agentsReject() {
+        return this.and(agentsReject());
+    }
+    agentsNotify() {
+        return this.and(agentsNotify());
+    }
+    systemOverwrite() {
+        return this.and(systemOverwrite());
+    }
+    systemReject() {
+        return this.and(systemReject());
+    }
+    systemNotify() {
+        return this.and(systemNotify());
+    }
+}
+/**
+ * Merges coordination rules into a single {@link ConflictAxis}. Later rules win
+ * on key collisions, and a committer kind you leave out falls through to the
+ * engine's default at commit time.
+ *
+ * ```ts
+ * coordination(humansOverwrite(), agentsReject())  // → { user: 'overwrite', agent: 'reject' }
+ * ```
+ */
+function mergeRules(...rules) {
+    return Object.assign({}, ...rules);
+}
+/**
+ * The coordination vocabulary, reachable through one name. Call it to merge
+ * rules you have assembled; reach through it to start a chain.
+ *
+ * ```ts
+ * conflict: coordination.humansOverwrite().agentsReject()
+ * conflict: coordination(humansOverwrite(), agentsReject())
+ * ```
+ */
+export const coordination = Object.assign(mergeRules, {
+    humansOverwrite: () => new CoordinationAxis(humansOverwrite()),
+    humansReject: () => new CoordinationAxis(humansReject()),
+    humansNotify: () => new CoordinationAxis(humansNotify()),
+    agentsOverwrite: () => new CoordinationAxis(agentsOverwrite()),
+    agentsReject: () => new CoordinationAxis(agentsReject()),
+    agentsNotify: () => new CoordinationAxis(agentsNotify()),
+    systemOverwrite: () => new CoordinationAxis(systemOverwrite()),
+    systemReject: () => new CoordinationAxis(systemReject()),
+    systemNotify: () => new CoordinationAxis(systemNotify()),
+});
+//# sourceMappingURL=coordination.js.map

package/dist/schema/coordination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordination.js","sourceRoot":"","sources":["../../src/schema/coordination.ts"],"names":[],"mappings":"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"}

package/dist/schema/ddl.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Turns a schema definition into the ordered Postgres DDL that provisions and
+ * migrates its tables. A schema built with `defineSchema(...)` and serialized to
+ * {@link SchemaJSON} is the single source of truth, and this module lowers it to
+ * ordered SQL strings.
+ *
+ * The same generators run wherever tables are created — in a hosted server
+ * applying them to the Postgres it manages, and in the `ablo migrate` CLI
+ * applying them to a customer's own Postgres — so the SQL, from column types to
+ * row-level security to enum checks, is identical no matter who runs it.
+ *
+ * Everything here is pure: it returns strings and touches no database. The
+ * execution side — the transaction and advisory lock that actually run the
+ * statements — lives with each caller, because it is coupled to that caller's
+ * Postgres client and error types.
+ *
+ *  - {@link generateProvisionPlan} builds an additive, idempotent plan (CREATE
+ *    and ADD … IF NOT EXISTS, plus row-level security) that never loses data —
+ *    the "create my tables" primitive.
+ *  - {@link generateMigrationPlan} is its destructive-aware counterpart, driven
+ *    by a {@link diffSchema} step list: drops, renames, type casts, and
+ *    backfills.
+ */
+import type { SchemaJSON, ModelJSON } from './serialize.js';
+import type { MigrationStep, BackfillValue } from './diff.js';
+export interface ProvisionPlan {
+    /** The Postgres schema the tables live in (`app_<id>` or `public`). */
+    readonly appSchema: string;
+    /** Ordered, idempotent DDL statements. Safe to run repeatedly. Executors run
+     *  these together in one transaction. */
+    readonly statements: readonly string[];
+    /** Post-commit, non-transactional DDL (`VALIDATE CONSTRAINT`, `CREATE INDEX
+     *  CONCURRENTLY`) — run after {@link statements} commit, each outside any
+     *  transaction, best-effort. Keeps the lock-heavy and scan-heavy work off the
+     *  main transaction so adding a foreign key never freezes a large, live table.
+     *  Optional: when absent, there is nothing to run. */
+    readonly concurrent?: readonly string[];
+}
+export interface ProvisionOptions {
+    /**
+     * Emit `DEFERRABLE INITIALLY DEFERRED` foreign-key constraints for the
+     * belongsTo relations that opt in; see {@link foreignKeyStatements} for exactly
+     * which relations qualify. Off by default, so soft references keep out-of-order
+     * sync robust. Turn it on for a customer's own database, where a clean,
+     * navigable relational schema is wanted and the database starts empty, so a
+     * constraint has nothing to fail against.
+     */
+    readonly foreignKeys?: boolean;
+}
+export interface MigrationPlan {
+    /** The app Postgres schema the DDL targets (`app_<id>` or `public`). */
+    readonly appSchema: string;
+    /** Ordered DDL statements (expand → contract). Run in one transaction. */
+    readonly statements: readonly string[];
+    /** Post-commit, non-transactional DDL — see {@link ProvisionPlan.concurrent}. */
+    readonly concurrent?: readonly string[];
+}
+/** Per-app schema name for an app (organization) id. */
+export declare function appSchemaName(organizationId: string): string;
+export declare function camelToSnake(identifier: string): string;
+/**
+ * Converts snake_case to camelCase — the inverse of {@link camelToSnake}. This
+ * is the read-side translation: a column read back from a customer's own
+ * database maps to the same JavaScript field the SDK wrote, so
+ * `camelToSnake('operatorId') === 'operator_id'` and
+ * `snakeToCamel('operator_id') === 'operatorId'` round-trip.
+ */
+export declare function snakeToCamel(identifier: string): string;
+/** Quote an identifier (defense-in-depth; inputs are already slug/snake). */
+export declare function q(identifier: string): string;
+export declare function sqlType(fieldType: ModelJSON['fields'][string]['type']): string;
+/**
+ * Builds the additive, idempotent provisioning plan for an app. Pure — it does
+ * not touch a database.
+ *
+ * `targetSchema` is where the tables live: a per-app Postgres schema such as
+ * `app_<id>`, or `public` when the database itself is the isolation boundary
+ * (for example a customer's own database). For `public` the `CREATE SCHEMA`
+ * statement is skipped, since it always exists.
+ */
+export declare function generateProvisionPlan(schema: SchemaJSON, targetSchema: string, opts?: ProvisionOptions): ProvisionPlan;
+/**
+ * Lower an ordered migration step list to DDL. `next` is the schema being pushed
+ * (the target column shapes are read from it), `prev` the active one (used to
+ * resolve the *old* table name on a model rename).
+ */
+export declare function generateMigrationPlan(steps: readonly MigrationStep[], opts: {
+    readonly prev: SchemaJSON | null;
+    readonly next: SchemaJSON;
+    readonly targetSchema: string;
+    /** Constant seed values that let a required-field add / made-required step
+     *  set NOT NULL on a non-empty table. Keyed by (model, field). */
+    readonly backfills?: readonly BackfillValue[];
+    /** Emit deferrable foreign-key constraints for the relations that opt in.
+     *  Off by default — see {@link ProvisionOptions.foreignKeys}. */
+    readonly foreignKeys?: boolean;
+}): MigrationPlan;
+//# sourceMappingURL=ddl.d.ts.map

package/dist/schema/ddl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ddl.d.ts","sourceRoot":"","sources":["../../src/schema/ddl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAa,MAAM,WAAW,CAAC;AAIzE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;6CACyC;IACzC,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;;;;0DAIsD;IACtD,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,iFAAiF;IACjF,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAUD,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,6EAA6E;AAC7E,wBAAgB,CAAC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE5C;AAID,wBAAgB,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM,CAiB9E;AAsID;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,EACpB,IAAI,GAAE,gBAAqB,GAC1B,aAAa,CAqFf;AA+CD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,IAAI,EAAE;IACJ,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;sEACkE;IAClE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C;qEACiE;IACjE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC,GACA,aAAa,CAkLf"}