@abloatai/ablo 0.36.0 → 0.37.0

package/dist/transaction/resources/where.js

@@ -1,115 +0,0 @@
-/**
- * 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',
-    });
-}

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

@@ -1,47 +0,0 @@
-/**
- * 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;

package/dist/transaction/resources/writeOptionsSchema.js

@@ -1,73 +0,0 @@
-/**
- * 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;

package/dist/transaction/schema/field.d.ts

@@ -1,120 +0,0 @@
-/**
- * Field builders for schema definitions. Each helper — {@link field}.string(),
- * .number(), .enum(), and so on — returns an ordinary Zod schema with a little
- * sync-engine metadata attached (its type tag and whether it is indexed) plus a
- * couple of chainable methods. The metadata is tucked into the schema's description
- * as a JSON string so it survives `.optional()`, `.nullable()`, and `.default()`
- * chaining, and {@link resolveFieldMeta} reads it back out as a {@link FieldMeta}.
- *
- * Usage:
- *   import { field } from '@abloatai/ablo/schema';
- *
- *   const tasks = model({
- *     title: field.string(),
- *     projectId: field.string().indexed(),     // fluent chain
- *     priority: field.number().optional(),
- *     status: field.enum(['todo', 'doing', 'done']),
- *   });
- *
- * Or use Zod directly (no metadata, but still works):
- *   import { z } from 'zod';
- *
- *   const tasks = model({
- *     title: z.string(),
- *   });
- */
-import { z } from 'zod';
-/**
- * The sync-engine metadata describing one field, available at runtime through a
- * model's `fields` map. The {@link field} builders attach it, and the migration
- * planner, type generator, and OpenAPI generator all read it.
- *
- * Declared in `wire/modelShape.ts` and inferred here, not restated: this record
- * crosses the wire twice — serialized into the pushed artifact, and reported
- * back by `GET /api/schema` — so a second declaration would be a copy that
- * drifts in whichever direction nobody is looking.
- */
-export type { FieldMeta } from '../wire/modelShape.js';
-import type { FieldMeta } from '../wire/modelShape.js';
-/**
- * Extract FieldMeta from a Zod schema. Returns null if no sync-engine
- * metadata is attached (e.g., raw `z.string()` usage).
- *
- * Walks through `.optional()` and `.nullable()` wrappers to find the
- * underlying description.
- */
-export declare function getFieldMeta(schema: z.ZodType): FieldMeta | null;
-/**
- * Infers a {@link FieldMeta} from a plain Zod schema that carries no field-builder
- * metadata — for example a bare `z.string()`. It unwraps `.optional()`,
- * `.nullable()`, and `.default()` to reach the inner type, then maps that Zod type
- * to a sync-engine type tag. Most callers should use {@link resolveFieldMeta}
- * instead, which tries the attached metadata first and falls back to this.
- */
-export declare function inferFieldMetaFromZod(schema: z.ZodType): FieldMeta;
-/**
- * Resolves a {@link FieldMeta} for any Zod schema, whether it was built with a
- * {@link field} builder (which attaches metadata) or with plain Zod (which needs
- * inference). This is the single entry point for "given a Zod field, tell me its
- * sync-engine type tag and whether it is optional"; the model and query builders use
- * it to populate their field maps, and the serializer reads those maps.
- *
- * It always returns a value and never returns null. A Zod type it does not recognize
- * falls through to the `string` tag by design.
- */
-export declare 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. */
-export type FieldBuilder<T extends z.ZodType> = T & {
-    indexed(): FieldBuilder<T>;
-    from(column: string): FieldBuilder<T>;
-};
-export declare const field: {
-    /** Defines a text field. */
-    readonly string: () => FieldBuilder<z.ZodString>;
-    /** Defines a numeric field. */
-    readonly number: () => FieldBuilder<z.ZodNumber>;
-    /** Defines a true/false field. */
-    readonly boolean: () => FieldBuilder<z.ZodBoolean>;
-    /** Defines a timestamp field, represented as a JavaScript `Date`. */
-    readonly date: () => FieldBuilder<z.ZodDate>;
-    /** Defines a field constrained to a fixed set of string values. */
-    readonly enum: <const T extends readonly [string, ...string[]]>(values: T) => FieldBuilder<z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>>;
-    /**
-     * Defines a JSON field, with three call shapes:
-     *
-     * ```ts
-     * field.json()                                        // unknown JSON blob
-     * field.json(z.array(z.string()))                     // typed JSON with Zod schema
-     * field.json({ icon: z.string().default('default') }) // typed sub-properties with defaults
-     * ```
-     *
-     * The third form is especially handy for metadata fields. It wraps the plain
-     * object in `z.object()` automatically, and the model runtime adds a
-     * `${field}Json` getter that parses the JSON string on read, applies the Zod
-     * defaults, and caches the result.
-     *
-     * Example:
-     * ```ts
-     * const reports = model({
-     *   metadata: field.json({
-     *     icon: z.string().default('report'),
-     *     color: z.string().default('#F59E0B'),
-     *     summary: z.string().optional(),
-     *   }),
-     * });
-     *
-     * // At runtime:
-     * report.metadata       // raw JSON string (unchanged)
-     * report.metadataJson   // { icon: 'report', color: '#F59E0B', summary: undefined }
-     * report.metadataJson.icon  // 'report' (typed, with default)
-     * ```
-     */
-    readonly json: <T extends z.ZodType = z.ZodUnknown>(schemaOrShape?: T | z.ZodRawShape) => FieldBuilder<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-    /** Defines an indexed text field — shorthand for `field.string().indexed()`. */
-    readonly id: () => FieldBuilder<z.ZodString>;
-};
-/** Marks a Zod schema as indexed so lookups on it use a database index. This is the
- *  standalone-function form of the `.indexed()` chain method. */
-export declare function indexed<T extends z.ZodType>(schema: T): T;

package/dist/transaction/schema/field.js

@@ -1,265 +0,0 @@
-/**
- * Field builders for schema definitions. Each helper — {@link field}.string(),
- * .number(), .enum(), and so on — returns an ordinary Zod schema with a little
- * sync-engine metadata attached (its type tag and whether it is indexed) plus a
- * couple of chainable methods. The metadata is tucked into the schema's description
- * as a JSON string so it survives `.optional()`, `.nullable()`, and `.default()`
- * chaining, and {@link resolveFieldMeta} reads it back out as a {@link FieldMeta}.
- *
- * Usage:
- *   import { field } from '@abloatai/ablo/schema';
- *
- *   const tasks = model({
- *     title: field.string(),
- *     projectId: field.string().indexed(),     // fluent chain
- *     priority: field.number().optional(),
- *     status: field.enum(['todo', 'doing', 'done']),
- *   });
- *
- * Or use Zod directly (no metadata, but still works):
- *   import { z } from 'zod';
- *
- *   const tasks = model({
- *     title: z.string(),
- *   });
- */
-import { z } from 'zod';
-import { AbloValidationError } from '../errors.js';
-// ── Helpers ───────────────────────────────────────────────────────────────
-/** Distinguish a Zod schema from a plain object shape (ZodRawShape). */
-function isZodSchema(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        '_def' in value &&
-        typeof value._def === 'object');
-}
-// ── Metadata encoding ─────────────────────────────────────────────────────
-//
-// We stash metadata in `.describe('__sync:{json}')` so it rides along with
-// the Zod schema through `.optional()`, `.nullable()`, etc. At schema-build
-// time we parse it back out into structured FieldMeta.
-const META_PREFIX = '__sync:';
-function encodeMeta(meta) {
-    return META_PREFIX + JSON.stringify(meta);
-}
-function decodeMeta(description) {
-    if (!description?.startsWith(META_PREFIX))
-        return null;
-    try {
-        return JSON.parse(description.slice(META_PREFIX.length));
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Extract FieldMeta from a Zod schema. Returns null if no sync-engine
- * metadata is attached (e.g., raw `z.string()` usage).
- *
- * Walks through `.optional()` and `.nullable()` wrappers to find the
- * underlying description.
- */
-export function getFieldMeta(schema) {
-    let current = schema;
-    let isOptional = false;
-    // Unwrap optional / nullable / default to reach the inner type
-    // (these are the wrappers that preserve .describe() but may hide it).
-    // `instanceof` keeps the narrowing typed; no `_def` digging.
-    const MAX_UNWRAP = 5;
-    for (let i = 0; i < MAX_UNWRAP; i++) {
-        if (current instanceof z.ZodOptional) {
-            isOptional = true;
-            current = current.unwrap();
-            continue;
-        }
-        if (current instanceof z.ZodNullable) {
-            isOptional = true;
-            current = current.unwrap();
-            continue;
-        }
-        if (current instanceof z.ZodDefault) {
-            // .removeDefault() — v4 deprecates in favor of .unwrap() but
-            // the installed @types only expose removeDefault on ZodDefault.
-            current = current.unwrap();
-            continue;
-        }
-        break;
-    }
-    // The description lives on the innermost schema we reached.
-    const description = current.description ?? schema.description;
-    const base = decodeMeta(description);
-    if (!base)
-        return null;
-    return { ...base, isOptional };
-}
-/**
- * Infers a {@link FieldMeta} from a plain Zod schema that carries no field-builder
- * metadata — for example a bare `z.string()`. It unwraps `.optional()`,
- * `.nullable()`, and `.default()` to reach the inner type, then maps that Zod type
- * to a sync-engine type tag. Most callers should use {@link resolveFieldMeta}
- * instead, which tries the attached metadata first and falls back to this.
- */
-export function inferFieldMetaFromZod(schema) {
-    let current = schema;
-    let isOptional = false;
-    const MAX_UNWRAP = 5;
-    for (let i = 0; i < MAX_UNWRAP; i++) {
-        if (current instanceof z.ZodOptional || current instanceof z.ZodNullable) {
-            isOptional = true;
-            current = current.unwrap();
-            continue;
-        }
-        if (current instanceof z.ZodDefault) {
-            current = current.unwrap();
-            continue;
-        }
-        break;
-    }
-    let type = 'string';
-    let enumValues;
-    if (current instanceof z.ZodString) {
-        type = 'string';
-    }
-    else if (current instanceof z.ZodNumber) {
-        type = 'number';
-    }
-    else if (current instanceof z.ZodBoolean) {
-        type = 'boolean';
-    }
-    else if (current instanceof z.ZodDate) {
-        type = 'date';
-    }
-    else if (current instanceof z.ZodEnum) {
-        type = 'enum';
-        // ZodEnum.options is the public v4 accessor for enum values.
-        enumValues = current.options;
-    }
-    else if (current instanceof z.ZodObject ||
-        current instanceof z.ZodArray ||
-        current instanceof z.ZodRecord ||
-        current instanceof z.ZodUnion ||
-        current instanceof z.ZodUnknown ||
-        // `z.custom<T>()` is opaque — its shape cannot be inspected — so it is treated
-        // as a JSON blob rather than falling through to the `'string'` default. The type
-        // tag drives how the runtime observes the field, and an opaque custom value
-        // should be tracked by reference rather than deeply.
-        current instanceof z.ZodCustom) {
-        type = 'json';
-    }
-    return { type, isOptional, isIndexed: false, enumValues };
-}
-/**
- * Resolves a {@link FieldMeta} for any Zod schema, whether it was built with a
- * {@link field} builder (which attaches metadata) or with plain Zod (which needs
- * inference). This is the single entry point for "given a Zod field, tell me its
- * sync-engine type tag and whether it is optional"; the model and query builders use
- * it to populate their field maps, and the serializer reads those maps.
- *
- * It always returns a value and never returns null. A Zod type it does not recognize
- * falls through to the `string` tag by design.
- */
-export function resolveFieldMeta(schema) {
-    const attached = getFieldMeta(schema);
-    if (attached)
-        return attached;
-    return inferFieldMetaFromZod(schema);
-}
-function assertColumnName(column) {
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/.test(column)) {
-        throw new AbloValidationError(`field.from(): invalid column identifier ${JSON.stringify(column)}`, { code: 'schema_definition_invalid' });
-    }
-}
-/** Add sync-engine chain methods to a Zod schema without disturbing its type. */
-function withFieldMethods(schema, meta) {
-    const described = schema.describe(encodeMeta(meta));
-    described.indexed = () => withFieldMethods(schema, { ...meta, isIndexed: true });
-    described.from = (column) => {
-        assertColumnName(column);
-        return withFieldMethods(schema, { ...meta, column });
-    };
-    return described;
-}
-function buildField(schema, baseMeta) {
-    return withFieldMethods(schema, { ...baseMeta, isIndexed: false });
-}
-export const field = {
-    /** Defines a text field. */
-    string() {
-        return buildField(z.string(), { type: 'string' });
-    },
-    /** Defines a numeric field. */
-    number() {
-        return buildField(z.number(), { type: 'number' });
-    },
-    /** Defines a true/false field. */
-    boolean() {
-        return buildField(z.boolean(), { type: 'boolean' });
-    },
-    /** Defines a timestamp field, represented as a JavaScript `Date`. */
-    date() {
-        return buildField(z.date(), { type: 'date' });
-    },
-    /** Defines a field constrained to a fixed set of string values. */
-    enum(values) {
-        return buildField(z.enum(values), { type: 'enum', enumValues: values });
-    },
-    /**
-     * Defines a JSON field, with three call shapes:
-     *
-     * ```ts
-     * field.json()                                        // unknown JSON blob
-     * field.json(z.array(z.string()))                     // typed JSON with Zod schema
-     * field.json({ icon: z.string().default('default') }) // typed sub-properties with defaults
-     * ```
-     *
-     * The third form is especially handy for metadata fields. It wraps the plain
-     * object in `z.object()` automatically, and the model runtime adds a
-     * `${field}Json` getter that parses the JSON string on read, applies the Zod
-     * defaults, and caches the result.
-     *
-     * Example:
-     * ```ts
-     * const reports = model({
-     *   metadata: field.json({
-     *     icon: z.string().default('report'),
-     *     color: z.string().default('#F59E0B'),
-     *     summary: z.string().optional(),
-     *   }),
-     * });
-     *
-     * // At runtime:
-     * report.metadata       // raw JSON string (unchanged)
-     * report.metadataJson   // { icon: 'report', color: '#F59E0B', summary: undefined }
-     * report.metadataJson.icon  // 'report' (typed, with default)
-     * ```
-     */
-    json(schemaOrShape) {
-        let inner;
-        if (!schemaOrShape) {
-            inner = z.unknown();
-        }
-        else if (isZodSchema(schemaOrShape)) {
-            inner = schemaOrShape;
-        }
-        else {
-            // Plain object shape → wrap in z.object() for the sub-property pattern
-            inner = z.object(schemaOrShape);
-        }
-        return buildField(inner, { type: 'json' });
-    },
-    /** Defines an indexed text field — shorthand for `field.string().indexed()`. */
-    id() {
-        return field.string().indexed();
-    },
-};
-// ── Function form ────────────────────────────────────────────────────────
-/** Marks a Zod schema as indexed so lookups on it use a database index. This is the
- *  standalone-function form of the `.indexed()` chain method. */
-export function indexed(schema) {
-    // Try to preserve existing metadata type tag if present.
-    const meta = decodeMeta(schema.description);
-    const newMeta = meta
-        ? { ...meta, isIndexed: true }
-        : { type: 'string', isIndexed: true };
-    return schema.describe(encodeMeta(newMeta));
-}

package/dist/transaction/schema/fieldRef.d.ts

@@ -1,38 +0,0 @@
-/**
- * A reference to one field of one model — the field as a value rather than as
- * a quoted name.
- *
- * A model is declared as Zod schemas keyed by name, so a field's name lives on
- * the object key and never on the value: `model({ status: z.enum([...]) })`
- * gives you nothing to point at, and every surface that needs to name a field
- * has had to quote it. `fields: ['titel']` then compiles, is granted, excludes
- * nobody, and leaves the write of `title` unguarded — the conflict rule
- * compares names as opaque strings, so an invented one matches no other claim
- * and nothing reports it.
- *
- * {@link Schema.fields} carries one of these per field, stamped from the key
- * `defineSchema` is already holding. Referencing a field that does not exist
- * stops compiling, and renaming one is a compile error at every use rather than
- * a claim that quietly stops matching.
- *
- * An object rather than a branded string, for the reason `ClaimPart` is one: a
- * brand makes a concrete schema's claim params mutually unassignable with the
- * erased `SchemaRecord` view, and the react context boundary erases and
- * restores exactly that way. Objects stay pairwise comparable across it, which
- * a union of literal keys does not — function parameters are contravariant, so
- * a claim accepting `'title' | 'status'` is not assignable to one accepting
- * `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.
- */
-export interface FieldRef {
-    /** The schema key of the model this field belongs to. */
-    readonly model: string;
-    /** The field's own name — the key it was declared under. */
-    readonly field: string;
-}
-/** Whether a value is a {@link FieldRef}. */
-export declare function isFieldRef(value: unknown): value is FieldRef;
-/** Build the reference for one declared field. */
-export declare function fieldRef(model: string, field: string): FieldRef;

package/dist/transaction/schema/fieldRef.js

@@ -1,11 +0,0 @@
-/** Whether a value is a {@link FieldRef}. */
-export function isFieldRef(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        typeof value.field === 'string' &&
-        typeof value.model === 'string');
-}
-/** Build the reference for one declared field. */
-export function fieldRef(model, field) {
-    return { model, field };
-}