@abloatai/transaction 0.50.0 → 0.52.0

package/src/schema/ddl.ts

@@ -117,7 +117,7 @@ export function sqlType(fieldType: ModelJSON['fields'][string]['type']): string
   }
 }
 
-const BASE_COLUMNS = new Set(['id', 'organization_id', 'created_by', 'created_at', 'updated_at']);
+const BASE_COLUMNS = new Set(['id']);
 
 // ── Foreign keys (relation-driven, sync-safe) ────────────────────────────────
 
@@ -154,11 +154,11 @@ interface ForeignKeyDdl {
  * in by setting `{ fk: true }`.
  *
  * The `fk` marker is deliberately separate from `parent`: `parent` controls
- * sync-group fan-out and visibility, while `fk` requests physical referential
+ * sync-group fan-out and visibility, while `fk` requests database referential
  * integrity in the database. A relation sets `fk` only when its target lives in
  * the same database, is written in the same commit, and is a strong, contained
  * entity. Soft references — provenance or template pointers such as
- * `sourceSlideId` or `templateId` — stay plain columns; a hard foreign key there
+ * `sourceDocumentId` or `templateId` — stay plain columns; a hard foreign key there
  * would reject a write that points across scopes or at an absent row and break
  * sync.
  *
@@ -204,7 +204,7 @@ function foreignKeyStatements(
   // The model's provisioned column set — guard so a relation whose FK field
   // isn't actually declared (no column) never produces a broken ALTER.
   const orgCol = tenancyColumn(resolveTenancy(model));
-  const columns = new Set<string>(['id', 'created_by', 'created_at', 'updated_at']);
+  const columns = new Set<string>(['id']);
   if (orgCol) columns.add(orgCol);
   for (const [fieldName, meta] of Object.entries(model.fields)) {
     columns.add(meta.column ?? camelToSnake(fieldName));
@@ -275,8 +275,7 @@ export function generateProvisionPlan(
     // declared boundary is what makes the set of tables a customer's own
     // database receives derivable instead of hand-coded.
     if ((model.plane ?? 'tenant') === 'control') continue;
-
-    // Default the physical table to the model key when `tableName` is omitted —
+    // Default the database table to the model key when `tableName` is omitted —
     // same fallback the migration path uses (`tableOfModel: m.tableName ?? key`).
     // Without this, a schema that doesn't set `tableName` (e.g. the `ablo init`
     // starter) provisions zero tables.
@@ -294,13 +293,10 @@ export function generateProvisionPlan(
     // no tenancy column — they're scoped via a parent FK or not at all.
     const orgCol = tenancyColumn(resolveTenancy(model));
     const baseColumns = [
-      `  ${q('id')} TEXT PRIMARY KEY,`,
-      ...(orgCol ? [`  ${q(orgCol)} TEXT NOT NULL,`] : []),
-      `  ${q('created_by')} TEXT,`,
-      `  ${q('created_at')} TIMESTAMPTZ NOT NULL DEFAULT NOW(),`,
-      `  ${q('updated_at')} TIMESTAMPTZ NOT NULL DEFAULT NOW()`,
+      `  ${q('id')} TEXT PRIMARY KEY`,
+      ...(orgCol ? [`  ${q(orgCol)} TEXT NOT NULL`] : []),
     ];
-    statements.push(`CREATE TABLE IF NOT EXISTS ${qt} (\n${baseColumns.join('\n')}\n);`);
+    statements.push(`CREATE TABLE IF NOT EXISTS ${qt} (\n${baseColumns.join(',\n')}\n);`);
 
     for (const [fieldName, meta] of Object.entries(model.fields)) {
       const col = meta.column ?? camelToSnake(fieldName);
@@ -458,7 +454,7 @@ export function generateMigrationPlan(
       case 'rename_model': {
         const fromTable = tableOfModel(prev, step.from);
         const toTable = tableOfModel(next, step.to);
-        // A logical model rename only needs SQL when the physical table name
+        // A logical model rename only needs SQL when the database table name
         // actually changes; if tableName is unchanged the rename is metadata.
         if (fromTable && toTable && fromTable !== toTable) {
           statements.push(`ALTER TABLE ${qtFor(fromTable)} RENAME TO ${q(toTable)};`);

package/src/schema/field.ts

@@ -9,7 +9,7 @@
  * Usage:
  *   import { field } from '@abloatai/transaction/schema';
  *
- *   const tasks = model({
+ *   const items = model({
  *     title: field.string(),
  *     projectId: field.string().indexed(),     // fluent chain
  *     priority: field.number().optional(),
@@ -19,7 +19,7 @@
  * Or use Zod directly (no metadata, but still works):
  *   import { z } from 'zod';
  *
- *   const tasks = model({
+ *   const items = model({
  *     title: z.string(),
  *   });
  */
@@ -199,7 +199,7 @@ export function resolveFieldMeta(schema: z.ZodType): FieldMeta {
 
 /** A Zod schema returned by a {@link field} builder — the underlying Zod type plus
  *  two chainable methods: `indexed()` marks the field for a database index, and
- *  `from(column)` overrides the physical column name it maps to. */
+ *  `from(column)` overrides the database column name it maps to. */
 export type FieldBuilder<T extends z.ZodType> = T & {
   indexed(): FieldBuilder<T>;
   from(column: string): FieldBuilder<T>;

package/src/schema/fieldRef.ts

@@ -24,7 +24,7 @@
  * `string`.
  *
  * `model` rides along so a reference carries where it came from. Claiming
- * `users.email` through `ablo.tasks` is a mistake nothing can currently see.
+ * `users.email` through `ablo.items` is a mistake nothing can currently see.
  */
 export interface FieldRef<
   Model extends string = string,

package/src/schema/generate.ts

@@ -10,9 +10,8 @@
  * that same schema, so the types you code against, the rows the database stores, and
  * the entities the sync layer moves all describe the same thing.
  *
- * The generated interface covers the base columns plus each declared field, with
- * enums emitted as string-literal unions. Relations are not expanded here — the
- * runtime SDK resolves those through its typed accessors.
+ * The generated interface covers storage-mode fields plus each declared field,
+ * with enums emitted as string-literal unions. Relations are not expanded here.
  */
 
 import type { FieldMeta } from './field.js';
@@ -70,12 +69,7 @@ export function generateTypes(schema: SchemaJSON): string {
   for (const [key, model] of Object.entries(schema.models)) {
     lines.push(`export interface ${nameByKey.get(key)!} {`);
     lines.push('  id: string;');
-    lines.push('  createdAt: Date;');
-    lines.push('  updatedAt: Date;');
-    lines.push('  organizationId?: string;');
-    lines.push('  createdBy?: string;');
     for (const [fieldName, meta] of Object.entries(model.fields)) {
-      // A model that redeclares a base column doesn't double-emit it.
       if ((BASE_FIELDS as readonly string[]).includes(fieldName)) continue;
       lines.push(`  ${fieldName}${meta.isOptional ? '?' : ''}: ${tsType(meta)};`);
     }

package/src/schema/index.ts

@@ -8,7 +8,7 @@
  * import { defineSchema, model, relation } from '@abloatai/transaction/schema';
  *
  * export const schema = defineSchema({
- *   tasks: model({
+ *   items: model({
  *     title: z.string(),
  *     status: z.enum(['todo', 'doing', 'done']).default('todo'),
  *     projectId: z.string().optional(),
@@ -17,7 +17,7 @@
  *   }),
  * });
  *
- * type Task = Model<typeof schema, 'tasks'>;
+ * type Item = Model<typeof schema, 'items'>;
  * ```
  */
 
@@ -27,7 +27,7 @@ export { z } from 'zod';
 // Field helpers (optional convenience wrappers around Zod)
 export { field, indexed, getFieldMeta, type FieldBuilder, type FieldMeta } from './field.js';
 
-// A field as a value rather than a quoted name — `schema.fields.tasks.status`.
+// A field as a value rather than a quoted name — `schema.fields.items.status`.
 // Surfaces that name a field (claims today) take one of these so a name that
 // does not exist stops compiling.
 export {

package/src/schema/model.ts

@@ -8,7 +8,7 @@
  *   import { z } from 'zod';
  *   import { model, relation } from '@abloatai/transaction/schema';
  *
- *   const tasks = model({
+ *   const items = model({
  *     title: z.string(),
  *     status: z.enum(['todo', 'doing', 'done']).default('todo'),
  *     projectId: z.string().optional(),
@@ -90,13 +90,13 @@ export interface ModelOptions {
    * Edges from this model to others, keyed by the accessor name they create. The
    * engine reads them to index foreign keys, to order inserts so a parent row lands
    * before the rows referencing it, and to generate the accessors that let you read
-   * `task.project` or `project.tasks` directly. Built with the {@link relation}
+   * `item.project` or `project.items` directly. Built with the {@link relation}
    * factories.
    *
    * ```ts
    * relations: {
    *   project: relation.belongsTo('projects', 'projectId'),
-   *   comments: relation.hasMany('comments', 'taskId'),
+   *   comments: relation.hasMany('comments', 'itemId'),
    * }
    * ```
    */
@@ -110,8 +110,8 @@ export interface ModelOptions {
   /**
    * The wire type name for this model — the value that identifies its rows on the
    * wire (the `__typename`). The loader stamps it onto incoming rows and uses it to
-   * find the matching model class. It defaults to the schema key (`tasks` →
-   * `'tasks'`); set it explicitly when the wire shape uses different casing, such as
+   * find the matching model class. It defaults to the schema key (`items` →
+   * `'items'`); set it explicitly when the wire shape uses different casing, such as
    * schema key `block` mapping to typename `'Block'`.
    *
    * This is the one value that identifies the model on the wire; the client-side
@@ -178,7 +178,7 @@ export interface ModelOptions {
    *   inbox. Accepts one role or many.
    *
    * ```ts
-   * // dataroomMember: { userId, dataroomId }
+   * // archiveMember: { userId, archiveId }
    * groups: { grants: { subject: 'user', scope: 'workspace' } }
    * // a message → its addressee's inbox, keyed on `toId`
    * groups: { roles: [entityRole({ kind: 'inbox', source: 'toId' })] }
@@ -395,7 +395,7 @@ export interface ModelDef<
  * const tags = model({ label: z.string() });
  *
  * // Loaded at bootstrap (the default), with an edge to its project
- * const tasks = model({
+ * const items = model({
  *   title: z.string(),
  *   status: z.enum(['todo', 'doing', 'done']).default('todo'),
  *   projectId: z.string().optional(),

package/src/schema/openapi.ts

@@ -208,8 +208,9 @@ const namedResp = (description: string, name: string): Json =>
  *
  * - `$schema` belongs on a standalone JSON Schema document, not every embedded
  *   OpenAPI Schema Object;
- * - `propertyNames: { type: 'string' }` is redundant for JSON objects and is
- *   unsupported by Stainless;
+ * - `propertyNames` constraining keys to strings is redundant for JSON objects,
+ *   whatever else it constrains, and is unsupported by Stainless. The key rule
+ *   still binds at runtime, where the Zod schema parses;
  * - `additionalProperties: {}` means "any JSON value", but Stainless requires
  *   the equivalent, explicit `true`.
  *
@@ -228,7 +229,6 @@ function portableSchema(value: unknown): unknown {
       key === 'propertyNames' &&
       typeof child === 'object' &&
       child !== null &&
-      Object.keys(child).length === 1 &&
       (child as Record<string, unknown>).type === 'string'
     ) {
       continue;
@@ -267,7 +267,7 @@ const modelParam = (): Json => ({
   in: 'path',
   required: true,
   schema: { type: 'string' },
-  description: 'A model name from your pushed schema, e.g. `task`.',
+  description: 'A model name from your pushed schema, e.g. `item`.',
 });
 const genericRow = (): Json => ({ type: 'object', additionalProperties: true });
 
@@ -591,9 +591,6 @@ export function abloOpenApi(options: SchemaToOpenApiOptions = {}): Json {
         description:
           'Call this first: every other route needs the key it returns. Requires a ' +
           'secret (`sk_`) key — a session cannot mint itself.',
-        parameters: [
-          { name: 'Idempotency-Key', in: 'header', schema: { type: 'string' }, description: 'Replay-safe key; the server returns the cached credential on retry.' },
-        ],
         requestBody: jsonBody(derive(ephemeralKeyRequestSchema, 'input')),
         responses: { '201': jsonResp('The minted credential', derive(EphemeralKeyResponseSchema, 'output')) },
       },

package/src/schema/queries.ts

@@ -44,7 +44,7 @@
  *    the factory and defers the cross-reference check to schema assembly.
  *
  *  - A query carries no `name` until `defineQueries()` assigns one from its
- *    record key — the same pattern `defineSchema({ tasks: model(...) })`
+ *    record key — the same pattern `defineSchema({ items: model(...) })`
  *    uses, where the model's name is the record key rather than a field on
  *    the factory.
  *

package/src/schema/relation.ts

@@ -4,15 +4,15 @@
  * {@link relation} factories; the engine reads them to index foreign keys for
  * fast child lookups, to order inserts so a parent row lands before the rows
  * that reference it, and to generate the accessor properties that let you read
- * `task.project` or `project.tasks` directly.
+ * `item.project` or `project.items` directly.
  *
  * Usage:
  *   import { relation } from '@abloatai/transaction/schema';
  *
- *   const taskRelations = {
+ *   const itemRelations = {
  *     project: relation.belongsTo('projects', 'projectId'),
  *     assignee: relation.belongsTo('users', 'assigneeId'),
- *     comments: relation.hasMany('comments', 'taskId'),
+ *     comments: relation.hasMany('comments', 'itemId'),
  *   };
  */
 
@@ -28,9 +28,9 @@
  * way often, such as a block's `sectionId`.
  *
  * `enrich: true` auto-populates the parent reference on an incoming change
- * before the child data lands. A change to `Task { teamId: 't1' }` picks up the
+ * before the child data lands. A change to `Item { teamId: 't1' }` picks up the
  * already-loaded `teams:t1` record and attaches it as `data.team`, so you can
- * read `task.team` without a second lookup. Enrichment is best-effort: if the
+ * read `item.team` without a second lookup. Enrichment is best-effort: if the
  * parent has not loaded yet it quietly does nothing, and the child data still
  * applies.
  *
@@ -71,7 +71,7 @@ export interface BelongsToOptions {
    * provenance or as a template, such as `sourceSectionId` or `templateId`; doing
    * so would leak the record into an unrelated scope. The engine also cannot
    * infer the parent from whether a field is optional — many real parent keys
-   * are optional, like a root folder or an inbox task — so you must declare the
+   * are optional, like a root folder or an inbox item — so you must declare the
    * parent edge explicitly.
    *
    * It reads naturally at the call site:
@@ -218,7 +218,7 @@ class RelationBuilder<
 export const relation = {
   /**
    * This model belongs to another model via a foreign key.
-   * e.g., Task belongs to Project via projectId
+   * e.g., Item belongs to Project via projectId
    *
    * ```ts
    * // Simple reference (no options)
@@ -252,7 +252,7 @@ export const relation = {
 
   /**
    * This model has many of another model — for example, a project has many
-   * tasks via `Task.projectId`.
+   * items via `Item.projectId`.
    *
    * At runtime the engine adds a getter to the parent model that returns every
    * child whose foreign key matches, and registers the foreign-key index on the

package/src/schema/residency.ts

@@ -27,4 +27,3 @@ export type ModelResidency = z.infer<typeof residencySchema>;
 
 /** Default residency for a model that doesn't declare one — the tenant data plane. */
 export const DEFAULT_RESIDENCY: ModelResidency = 'tenant';
-

package/src/schema/schema.ts

@@ -8,20 +8,20 @@
  *   import { defineSchema, model, relation } from '@abloatai/transaction/schema';
  *
  *   const schema = defineSchema({
- *     tasks: model({
+ *     items: model({
  *       title: z.string(),
  *       status: z.enum(['todo', 'doing', 'done']).default('todo'),
- *       projectId: z.string().optional(),
+ *       workspaceId: z.string().optional(),
  *     }, {
- *       project: relation.belongsTo('projects', 'projectId'),
+ *       workspace: relation.belongsTo('workspaces', 'workspaceId'),
  *     }),
  *   });
  *
- *   type Task = InferModel<typeof schema, 'tasks'>;
+ *   type Item = InferModel<typeof schema, 'items'>;
  */
 
 import { z } from 'zod';
-import type { ModelDef, RelationRecord } from './model.js';
+import type { ComputedRecord, ModelDef, RelationRecord } from './model.js';
 import type { RelationDef } from './relation.js';
 import { AbloValidationError } from '../errors.js';
 import type { IdentityRole } from './roles.js';
@@ -210,7 +210,7 @@ export interface DefineSchemaOptions {
 export type SchemaRecord = Record<string, ModelDef>;
 
 /**
- * Base fields every synced model gets automatically.
+ * The logical identity every model gets automatically.
  *
  * Exported (internal) so `parseSchema` can rebuild a model's validator the
  * same way `defineSchema` does — `baseFieldsSchema.merge(modelSchema)` — when
@@ -218,26 +218,14 @@ export type SchemaRecord = Record<string, ModelDef>;
  */
 export const baseFieldsSchema = z.object({
   id: z.string(),
-  createdAt: z.date(),
-  updatedAt: z.date(),
-  organizationId: z.string().optional(),
-  createdBy: z.string().optional(),
 });
 
 /**
- * The base-column names every model carries automatically — the keys of
- * {@link baseFieldsSchema}, kept here as the single source of truth. Code
- * generation reads it to avoid emitting a base column twice, and
- * {@link defineSchema} uses it to reject a model that redeclares one, since
- * merging the user's field over the base field would produce a `string & Date`
- * type and break the build.
+ * The universal model field names. Audit and application metadata is declared
+ * by the application or carried by the commit record, never injected here.
  */
 export const BASE_FIELDS = [
   'id',
-  'createdAt',
-  'updatedAt',
-  'organizationId',
-  'createdBy',
 ] as const;
 
 /** The base fields type — pure data columns. */
@@ -262,15 +250,15 @@ export interface Schema<S extends SchemaRecord = SchemaRecord> {
 
   /**
    * Every declared field as a {@link FieldRef} — the field as a value rather
-   * than a quoted name: `schema.fields.tasks.status`.
+   * than a quoted name: `schema.fields.items.status`.
    *
    * A surface that names a field takes one of these instead of a string, so a
    * name that does not exist stops compiling and a rename is a compile error at
    * every use. Claims are the first caller; anything else that has to say
    * "which field" should take a reference for the same reason.
    *
-   * Base fields (`id`, `createdAt`, …) are not here: the schema does not
-   * declare them, and a caller naming one means the row, not a part of it.
+   * Automatically supplied `id` is not here. Every application-declared field
+   * does appear here.
    */
   readonly fields: {
     readonly [K in keyof S & string]: S[K] extends ModelDef<infer Shape>
@@ -281,7 +269,7 @@ export interface Schema<S extends SchemaRecord = SchemaRecord> {
       : never;
   };
 
-  /** Zod schemas with base fields merged in */
+  /** Zod schemas with logical identity merged into each declared model shape. */
   readonly validators: {
     readonly [K in keyof S]: S[K] extends ModelDef<infer Shape>
       ? z.ZodObject<Shape & typeof baseFieldsSchema.shape>
@@ -339,7 +327,7 @@ export interface Schema<S extends SchemaRecord = SchemaRecord> {
  * Includes base fields (id, createdAt, updatedAt, etc.)
  *
  * ```ts
- * type Task = InferModel<typeof schema, 'tasks'>;
+ * type Item = InferModel<typeof schema, 'items'>;
  * ```
  */
 /** The schema bound via `declare module … interface Register { Schema: … }`
@@ -351,15 +339,15 @@ type RegisteredSchema = import('../types/global.js').Register extends {
   : never;
 
 /**
- * The primary model-type helper. Once your project's `ablo/register.ts`
+ * The primary model-type helper. Once your workspace's `ablo/register.ts`
  * registers the schema, a single argument is all it takes:
  *
  * ```ts
- * type Task = Model<'tasks'>;
+ * type Item = Model<'items'>;
  * ```
  *
  * Without that registration, or for a second schema, pass the schema
- * explicitly: `Model<typeof schema, 'tasks'>`.
+ * explicitly: `Model<typeof schema, 'items'>`.
  */
 export type Model<A, B = never> = [B] extends [never]
   ? A extends keyof RegisteredSchema['models']
@@ -371,21 +359,14 @@ export type Model<A, B = never> = [B] extends [never]
 
 /**
  * The row type {@link Model} resolves to. Internal: `Model<typeof schema,
- * 'tasks'>` is the published spelling, because it reads as the domain rather
+ * 'items'>` is the published spelling, because it reads as the domain rather
  * than the machinery. This one is no longer exported from any subpath — it
  * stays because `Model` is defined in terms of it, not as a second name for
  * the same idea.
  */
 export type InferModel<S extends Schema, ModelName extends keyof S['models']> =
   S['models'][ModelName] extends ModelDef<infer Shape, infer R, infer C>
-    ? // `Omit<…, keyof BaseModelFields>` so a model that (wrongly) redeclares a
-      // reserved field degrades to "framework field wins" (e.g. `createdAt: Date`)
-      // instead of intersecting to `never` (`string & Date`, which then surfaces
-      // as a baffling "missing field" error three layers away). defineSchema also
-      // throws on such a redeclaration at runtime (code `schema_reserved_field`);
-      // this is the type-level belt to that runtime suspenders. No-op for correct
-      // schemas — they never carry a base-field key, so nothing is omitted.
-      Omit<z.infer<z.ZodObject<Shape>>, keyof BaseModelFields>
+    ? Omit<z.infer<z.ZodObject<Shape>>, 'id'>
         & BaseModelFields
         & BaseModelMethods
         & InferComputed<C>
@@ -452,14 +433,13 @@ export type InferRelations<S extends Schema, R extends RelationRecord> =
  */
 export type InferRow<S extends Schema, ModelName extends keyof S['models']> =
   S['models'][ModelName] extends ModelDef<infer Shape, RelationRecord, infer C>
-    ? // Same reserved-field guard as InferModel — see the comment there.
-      Omit<z.infer<z.ZodObject<Shape>>, keyof BaseModelFields>
+    ? Omit<z.infer<z.ZodObject<Shape>>, 'id'>
         & BaseModelFields
         & InferComputed<C>
     : never;
 
 /**
- * The reactive-row companion to {@link Model}. Once your project's
+ * The reactive-row companion to {@link Model}. Once your workspace's
  * `ablo/register.ts` registers the schema, a single argument is all it takes:
  *
  * ```ts
@@ -500,26 +480,22 @@ export type InferComputed<C> =
     : { readonly [K in keyof C]: C[K] extends (...args: any[]) => infer R ? R : never };
 
 /**
- * Infer the create input type. Only schema-defined fields are accepted —
- * base fields (id, createdAt, updatedAt) are auto-generated by the SDK
- * and cannot be passed by the consumer.
+ * Infer the create input type. Application fields retain their declared input
+ * requirements and types.
  *
  * The only exception is `id`: consumers can optionally provide one for
  * client-generated IDs (useful for optimistic UI that needs to reference
  * the entity before the server confirms).
  *
  * ```ts
- * type CreateTask = InferCreate<typeof schema, 'tasks'>;
+ * type CreateItem = InferCreate<typeof schema, 'items'>;
  * // { title: string; status?: 'todo' | 'doing' | 'done'; id?: string }
- * // createdAt, updatedAt are NOT accepted — they're auto-generated
  * ```
  */
 export type InferCreate<S extends Schema, ModelName extends keyof S['models']> =
   S['models'][ModelName] extends ModelDef<infer Shape>
-    ? // Same reserved-field guard as InferModel: drop any (wrongly) redeclared
-      // base field so the input degrades to "framework field wins" rather than
-      // collapsing to `never`. No-op for correct schemas.
-      Omit<z.input<z.ZodObject<Shape>>, keyof BaseModelFields> & Partial<BaseModelFields>
+    ? Omit<z.input<z.ZodObject<Shape>>, 'id'>
+        & Partial<Pick<BaseModelFields, 'id'>>
     : never;
 
 /**
@@ -570,8 +546,8 @@ export interface DeleteId<S extends Schema, ModelName extends keyof S['models']>
  *
  * ```ts
  * const schema = defineSchema({
- *   tasks: model({ title: z.string(), status: z.string().default('todo') }),
- *   projects: model({ name: z.string() }),
+ *   items: model({ title: z.string(), status: z.string().default('todo') }),
+ *   workspaces: model({ name: z.string() }),
  * });
  * ```
  */
@@ -682,16 +658,15 @@ export function defineSchema<const S extends SchemaRecord>(
     // failure immediate and unambiguous.
     for (const fieldName of Object.keys(def.shape)) {
       assertRoundTrippableCamelCase(name, fieldName);
-      // Reserved base columns are merged in below via `baseFieldsSchema.merge`,
-      // and Zod `.merge` silently OVERWRITES the base field with the user's —
-      // e.g. a model declaring `createdAt: z.string()` ends up with a field
-      // typed `string & Date`, which breaks the build. Reject the collision at
-      // definition time so the author sees an unambiguous error instead.
-      if ((BASE_FIELDS as readonly string[]).includes(fieldName)) {
+      // Logical identity is the only universal model field. Application
+      // timestamps, tenancy columns and attribution columns are ordinary
+      // fields when an application declares them.
+      const reservedFields = ['id'];
+      if ((reservedFields as readonly string[]).includes(fieldName)) {
         throw new AbloValidationError(
           `[defineSchema] ${name}.${fieldName}: field \`${fieldName}\` collides with a ` +
             `reserved field that the SDK provides automatically ` +
-            `(${BASE_FIELDS.join(', ')}). Remove it from your model — redeclaring it ` +
+            `(${reservedFields.join(', ')}). Remove it from your model — redeclaring it ` +
             `produces a \`string & Date\` type and breaks the build.`,
           { code: 'schema_reserved_field', param: `${name}.${fieldName}` },
         );

package/src/schema/sugar.ts

@@ -15,10 +15,10 @@
  *
  * @example
  * ```ts
- * tasks: mutable.lazy({ title: z.string() }, {
- *   typename: 'Task', tableName: 'tasks',
+ * items: mutable.lazy({ title: z.string() }, {
+ *   typename: 'Item', tableName: 'items',
  *   relations: { ... },
- *   computed: tasksComputed,
+ *   computed: itemsComputed,
  * }),
  * ```
  */
@@ -47,13 +47,13 @@ export interface SugarOptions<
   /** Computed getters installed on the model class prototype. */
   computed?: C;
   /**
-   * Wire `__typename` (PascalCase, e.g. `'Task'`). Defaults to the schema
+   * Wire `__typename` (PascalCase, e.g. `'Item'`). Defaults to the schema
    * key via `defineSchema` — override when the wire shape differs from
    * the camelCase schema key.
    */
   typename?: string;
   /**
-   * The physical table name. Override it when the table name differs from the
+   * The database table name. Override it when the table name differs from the
    * snake_case of the typename — for example, a `Member` type stored in a table
    * named `'member'` rather than `'members'`.
    */
@@ -112,9 +112,9 @@ function build<
  * `{ mutable: true, load: X }` on `model()`.
  *
  * Pick the load suffix by data-access pattern:
- *   - `.instant`  — small, always-needed (Theme, Layout, StatusGroup)
+ *   - `.instant`  — small, always-needed control rows
  *   - `.lazy`     — large collections fetched on first query
- *     (Block, Message, Task)
+ *     (Block, Message, Item)
  */
 export const mutable = {
   instant: <

package/src/server/commit.ts

@@ -16,6 +16,7 @@
 import type { ParticipantKind, ConfirmationState } from '../log/syncDeltaRow.js';
 import type { ParticipantRef } from '../wire/delta.js';
 import type { CommitExecutionResultInput } from '../wire/commit.js';
+import type { CommitOperationResult } from '../wire/commit.js';
 import type { ReadDependency, TrackDependency } from '../coordination/schema.js';
 import type { EffectiveAuthority } from '../auth/capability.js';
 
@@ -99,4 +100,7 @@ export interface CommitContext {
  * lives with the HTTP/WS confirmation contract so queued correlation cannot drift
  * between cache, transport, and client.
  */
-export type CommitExecutionResult = CommitExecutionResultInput;
+export type CommitExecutionResult = CommitExecutionResultInput & {
+  /** Response-time projection from the exact writing transaction. Never persisted. */
+  readonly operationResults?: readonly CommitOperationResult[];
+};

package/src/source/adapters/drizzle.ts

@@ -151,6 +151,11 @@ export function drizzleDataSource<S extends SchemaRecord>(
   };
 
   const applyOperation = async (tx: DrizzleLike, op: Operation): Promise<Row> => {
+    if (op.where) {
+      throw new AbloValidationError('The Drizzle adapter does not support conditional operations', {
+        code: 'source_adapter_misconfigured',
+      });
+    }
     const mc = modelColumns(op.model);
     const table = sql.identifier(mc.table);
     const id = rowId(op);