@stndrds/schema 1.0.0-alpha.282 → 1.0.0-alpha.285

package/dist/{attributes-CU871AfG.d.ts → attributes-CNYwg_Nr.d.ts}

@@ -132,7 +132,8 @@ type OptionPropertyAttribute = SelectAttribute | StatusAttribute | MultiselectAt
  */
 declare function hasOptions(attr: PropertyAttribute): attr is OptionPropertyAttribute;
 
-type AttributeType = "text" | "richtext" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "location" | "select" | "multiselect" | "user" | "relation" | "formula" | "rollup" | "document";
+declare const ATTRIBUTE_TYPES: readonly ["text", "richtext", "number", "checkbox", "date", "phone", "currency", "status", "location", "select", "multiselect", "user", "relation", "formula", "rollup", "document"];
+type AttributeType = (typeof ATTRIBUTE_TYPES)[number];
 /**
  * Status group categorization
  */
@@ -580,4 +581,4 @@ declare function isAttributeSortable(attr: {
     type: AttributeType;
 }): boolean;
 
-export { type PropertyType as $, type Attribute as A, type BilateralConfig as B, type CurrencyAttribute as C, type DateAttribute as D, type AttributeGroup as E, type FormulaAttribute as F, type BaseAttribute as G, type ComputedFieldKind as H, type ComputedFormulaBinaryNode as I, type ComputedFormulaBinaryOperator as J, type ComputedFormulaCallNode as K, type LocationAttribute as L, type MultiRelationAttribute as M, type NumberAttribute as N, type Option as O, type PhoneAttribute as P, type ComputedFormulaLiteralNode as Q, type RelationAttribute as R, type SingleRelationAttribute as S, type TextAttribute as T, type UserAttribute as U, ComputedFormulaParseError as V, type ComputedFormulaPathNode as W, type DateFormat as X, type DateValue as Y, type NumberUnit as Z, type OptionPropertyAttribute as _, type RichtextAttribute as a, RELATION_TARGET_ANY as a0, type RichTextAttribute as a1, type StatusGroup as a2, hasOptions as a3, inferInverseCardinality as a4, isAttributeSortable as a5, isBilateralRelation as a6, isUniversalRelation as a7, parseComputedFormula as a8, resolvePropertyDefinitions as a9, type MultiselectAttribute as b, type SelectAttribute as c, type StatusAttribute as d, type RollupAttribute as e, type AttributeType as f, type CheckboxAttribute as g, type ComputedValueType as h, type ComputedReturnType as i, type ComputedOptionsSource as j, type ComputedDependency as k, type ComputedPlan as l, type ComputedFormulaAstNode as m, type LocationGranularity as n, type Location as o, type DateRangeValue as p, type DocumentAttribute as q, type Phone as r, type Currency as s, type PropertySchema as t, type TimeFormat as u, type PropertyAttribute as v, type FormulaReturnType as w, type RelationTarget as x, type RollupFunction as y, type UserReferenceType as z };
+export { type OptionPropertyAttribute as $, type Attribute as A, type BilateralConfig as B, type CurrencyAttribute as C, type DateAttribute as D, ATTRIBUTE_TYPES as E, type FormulaAttribute as F, type AttributeGroup as G, type BaseAttribute as H, type ComputedFieldKind as I, type ComputedFormulaBinaryNode as J, type ComputedFormulaBinaryOperator as K, type LocationAttribute as L, type MultiRelationAttribute as M, type NumberAttribute as N, type Option as O, type PhoneAttribute as P, type ComputedFormulaCallNode as Q, type RelationAttribute as R, type SingleRelationAttribute as S, type TextAttribute as T, type UserAttribute as U, type ComputedFormulaLiteralNode as V, ComputedFormulaParseError as W, type ComputedFormulaPathNode as X, type DateFormat as Y, type DateValue as Z, type NumberUnit as _, type RichtextAttribute as a, type PropertyType as a0, RELATION_TARGET_ANY as a1, type RichTextAttribute as a2, type StatusGroup as a3, hasOptions as a4, inferInverseCardinality as a5, isAttributeSortable as a6, isBilateralRelation as a7, isUniversalRelation as a8, parseComputedFormula as a9, resolvePropertyDefinitions as aa, type MultiselectAttribute as b, type SelectAttribute as c, type StatusAttribute as d, type RollupAttribute as e, type AttributeType as f, type CheckboxAttribute as g, type ComputedValueType as h, type ComputedReturnType as i, type ComputedOptionsSource as j, type ComputedDependency as k, type ComputedPlan as l, type ComputedFormulaAstNode as m, type LocationGranularity as n, type Location as o, type DateRangeValue as p, type DocumentAttribute as q, type Phone as r, type Currency as s, type PropertySchema as t, type TimeFormat as u, type PropertyAttribute as v, type FormulaReturnType as w, type RelationTarget as x, type RollupFunction as y, type UserReferenceType as z };

package/dist/{attributes-DoiGyNFk.d.mts → attributes-CWPLbp7c.d.mts}

@@ -132,7 +132,8 @@ type OptionPropertyAttribute = SelectAttribute | StatusAttribute | MultiselectAt
  */
 declare function hasOptions(attr: PropertyAttribute): attr is OptionPropertyAttribute;
 
-type AttributeType = "text" | "richtext" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "location" | "select" | "multiselect" | "user" | "relation" | "formula" | "rollup" | "document";
+declare const ATTRIBUTE_TYPES: readonly ["text", "richtext", "number", "checkbox", "date", "phone", "currency", "status", "location", "select", "multiselect", "user", "relation", "formula", "rollup", "document"];
+type AttributeType = (typeof ATTRIBUTE_TYPES)[number];
 /**
  * Status group categorization
  */
@@ -580,4 +581,4 @@ declare function isAttributeSortable(attr: {
     type: AttributeType;
 }): boolean;
 
-export { type PropertyType as $, type Attribute as A, type BilateralConfig as B, type CurrencyAttribute as C, type DateAttribute as D, type AttributeGroup as E, type FormulaAttribute as F, type BaseAttribute as G, type ComputedFieldKind as H, type ComputedFormulaBinaryNode as I, type ComputedFormulaBinaryOperator as J, type ComputedFormulaCallNode as K, type LocationAttribute as L, type MultiRelationAttribute as M, type NumberAttribute as N, type Option as O, type PhoneAttribute as P, type ComputedFormulaLiteralNode as Q, type RelationAttribute as R, type SingleRelationAttribute as S, type TextAttribute as T, type UserAttribute as U, ComputedFormulaParseError as V, type ComputedFormulaPathNode as W, type DateFormat as X, type DateValue as Y, type NumberUnit as Z, type OptionPropertyAttribute as _, type RichtextAttribute as a, RELATION_TARGET_ANY as a0, type RichTextAttribute as a1, type StatusGroup as a2, hasOptions as a3, inferInverseCardinality as a4, isAttributeSortable as a5, isBilateralRelation as a6, isUniversalRelation as a7, parseComputedFormula as a8, resolvePropertyDefinitions as a9, type MultiselectAttribute as b, type SelectAttribute as c, type StatusAttribute as d, type RollupAttribute as e, type AttributeType as f, type CheckboxAttribute as g, type ComputedValueType as h, type ComputedReturnType as i, type ComputedOptionsSource as j, type ComputedDependency as k, type ComputedPlan as l, type ComputedFormulaAstNode as m, type LocationGranularity as n, type Location as o, type DateRangeValue as p, type DocumentAttribute as q, type Phone as r, type Currency as s, type PropertySchema as t, type TimeFormat as u, type PropertyAttribute as v, type FormulaReturnType as w, type RelationTarget as x, type RollupFunction as y, type UserReferenceType as z };
+export { type OptionPropertyAttribute as $, type Attribute as A, type BilateralConfig as B, type CurrencyAttribute as C, type DateAttribute as D, ATTRIBUTE_TYPES as E, type FormulaAttribute as F, type AttributeGroup as G, type BaseAttribute as H, type ComputedFieldKind as I, type ComputedFormulaBinaryNode as J, type ComputedFormulaBinaryOperator as K, type LocationAttribute as L, type MultiRelationAttribute as M, type NumberAttribute as N, type Option as O, type PhoneAttribute as P, type ComputedFormulaCallNode as Q, type RelationAttribute as R, type SingleRelationAttribute as S, type TextAttribute as T, type UserAttribute as U, type ComputedFormulaLiteralNode as V, ComputedFormulaParseError as W, type ComputedFormulaPathNode as X, type DateFormat as Y, type DateValue as Z, type NumberUnit as _, type RichtextAttribute as a, type PropertyType as a0, RELATION_TARGET_ANY as a1, type RichTextAttribute as a2, type StatusGroup as a3, hasOptions as a4, inferInverseCardinality as a5, isAttributeSortable as a6, isBilateralRelation as a7, isUniversalRelation as a8, parseComputedFormula as a9, resolvePropertyDefinitions as aa, type MultiselectAttribute as b, type SelectAttribute as c, type StatusAttribute as d, type RollupAttribute as e, type AttributeType as f, type CheckboxAttribute as g, type ComputedValueType as h, type ComputedReturnType as i, type ComputedOptionsSource as j, type ComputedDependency as k, type ComputedPlan as l, type ComputedFormulaAstNode as m, type LocationGranularity as n, type Location as o, type DateRangeValue as p, type DocumentAttribute as q, type Phone as r, type Currency as s, type PropertySchema as t, type TimeFormat as u, type PropertyAttribute as v, type FormulaReturnType as w, type RelationTarget as x, type RollupFunction as y, type UserReferenceType as z };

package/dist/capabilities.d.mts

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+
+/** Accepted forms of the object identifier every object-scoped capability takes. */
+declare const OBJECT_ID_DESCRIPTION = "Object UUID, kebab-case name (e.g., 'contacts'), or display label (e.g., 'Personne physique'). All three are accepted; UUID is most precise.";
+/** Shared suffix for record `data` inputs that accept `$fromSandboxFile` references for large content. */
+declare const SANDBOX_FILE_DATA_HINT = " For large text content (> a few KB), write it to a sandbox file first and pass {\"$fromSandboxFile\": \"/workspace/<file>\"} as the attribute value \u2014 the server substitutes the file content.";
+/**
+ * The LLM-facing filter shape, deliberately looser than its two siblings:
+ * `types/filters.ts` (`FilterState`, the canonical TS model — its `quantifier`
+ * is omitted here on purpose, agents don't set edge quantifiers) and
+ * `validators/view-config.schema.ts` (`filterStateSchema`, the strict capped
+ * variant for stored view config). The operator list in the describe text
+ * restates `filters/operators.ts` (`OPERATOR_SPECS`) and
+ * `filters/normalize-operator.ts` (`SYNONYM_ALIASES`) — those are the source
+ * of truth; keep the prose in sync when adding an operator.
+ */
+declare const filtersSchema: z.ZodObject<{
+    combinator: z.ZodDefault<z.ZodEnum<{
+        and: "and";
+        or: "or";
+    }>>;
+    rules: z.ZodArray<z.ZodObject<{
+        attribute: z.ZodString;
+        property: z.ZodOptional<z.ZodString>;
+        operator: z.ZodString;
+        value: z.ZodNullable<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const sortsSchema: z.ZodArray<z.ZodObject<{
+    attribute: z.ZodString;
+    direction: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>;
+}, z.core.$strip>>;
+/**
+ * Filter shapes derived from {@link filtersSchema} so the capability schema stays
+ * the single source of truth.
+ *
+ * The *parsed* shape (`z.infer`), deliberately: the runtime holds these after
+ * validation, when `combinator` has already been defaulted. What a caller may
+ * omit is `z.input`, and that is what {@link CapabilityInput} exposes.
+ */
+type FilterStateInput = z.infer<typeof filtersSchema>;
+type FilterRuleInput = FilterStateInput["rules"][number];
+/** How a capability mutates data, which decides whether a rehearsal captures it. */
+type CapabilityKind = "read" | "create" | "update" | "delete";
+/**
+ * Every capability a Reflex may call, defined once.
+ *
+ * Deliberately five entries — the single-record tools whose input the gateway can
+ * turn into a faithful `RunEffect`. Excluded on purpose: `get_schema`,
+ * `global_search` and `bulk_search`, which are not scoped to one object and so
+ * yield no object to grant a permission on; and the `bulk_*` record tools, where
+ * one call mutates many records and would be recorded as a single effect, making
+ * an effects report understate what happened.
+ *
+ * `description` is NOT here: the tools compute it per call from their config
+ * (`schemaInContext` changes the wording), and `schema-tools-descriptions.test.ts`
+ * pins both variants. The name, the kind and the input schema are what must exist
+ * exactly once, and they do.
+ */
+declare const RECORD_CAPABILITIES: {
+    readonly get_record: {
+        readonly name: "get_record";
+        readonly kind: "read";
+        readonly input: z.ZodObject<{
+            recordId: z.ZodString;
+            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    };
+    readonly search_records: {
+        readonly name: "search_records";
+        readonly kind: "read";
+        readonly input: z.ZodObject<{
+            objectId: z.ZodString;
+            _displayLabel: z.ZodOptional<z.ZodString>;
+            query: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            filters: z.ZodOptional<z.ZodObject<{
+                combinator: z.ZodDefault<z.ZodEnum<{
+                    and: "and";
+                    or: "or";
+                }>>;
+                rules: z.ZodArray<z.ZodObject<{
+                    attribute: z.ZodString;
+                    property: z.ZodOptional<z.ZodString>;
+                    operator: z.ZodString;
+                    value: z.ZodNullable<z.ZodUnknown>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            sorts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                attribute: z.ZodString;
+                direction: z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly create_record: {
+        readonly name: "create_record";
+        readonly kind: "create";
+        readonly input: z.ZodObject<{
+            objectId: z.ZodString;
+            _displayLabel: z.ZodOptional<z.ZodString>;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>;
+    };
+    readonly update_record: {
+        readonly name: "update_record";
+        readonly kind: "update";
+        readonly input: z.ZodObject<{
+            recordId: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>;
+    };
+    readonly delete_record: {
+        readonly name: "delete_record";
+        readonly kind: "delete";
+        readonly input: z.ZodObject<{
+            recordId: z.ZodString;
+        }, z.core.$strip>;
+    };
+};
+type RecordCapabilityName = keyof typeof RECORD_CAPABILITIES;
+/**
+ * A capability's argument type, inferred from the very schema the runtime
+ * validates against.
+ *
+ * `z.input`, not `z.infer`: these are the arguments a caller supplies, and the
+ * two sides differ wherever a field has a `.default()` — `filtersSchema`'s
+ * `combinator` is required on the output and optional on the input. Typing
+ * arguments with the output side made the SDK demand a `combinator` the runtime
+ * would have filled in anyway.
+ */
+type CapabilityInput<N extends RecordCapabilityName> = z.input<(typeof RECORD_CAPABILITIES)[N]["input"]>;
+/**
+ * The capability → kind projection, derived rather than restated. The reflexes
+ * module reads this instead of maintaining its own table (D26/D28).
+ */
+declare const RECORD_CAPABILITY_KINDS: Readonly<Record<RecordCapabilityName, CapabilityKind>>;
+
+export { type CapabilityInput, type CapabilityKind, type FilterRuleInput, type FilterStateInput, OBJECT_ID_DESCRIPTION, RECORD_CAPABILITIES, RECORD_CAPABILITY_KINDS, type RecordCapabilityName, SANDBOX_FILE_DATA_HINT, filtersSchema, sortsSchema };

package/dist/capabilities.d.ts

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+
+/** Accepted forms of the object identifier every object-scoped capability takes. */
+declare const OBJECT_ID_DESCRIPTION = "Object UUID, kebab-case name (e.g., 'contacts'), or display label (e.g., 'Personne physique'). All three are accepted; UUID is most precise.";
+/** Shared suffix for record `data` inputs that accept `$fromSandboxFile` references for large content. */
+declare const SANDBOX_FILE_DATA_HINT = " For large text content (> a few KB), write it to a sandbox file first and pass {\"$fromSandboxFile\": \"/workspace/<file>\"} as the attribute value \u2014 the server substitutes the file content.";
+/**
+ * The LLM-facing filter shape, deliberately looser than its two siblings:
+ * `types/filters.ts` (`FilterState`, the canonical TS model — its `quantifier`
+ * is omitted here on purpose, agents don't set edge quantifiers) and
+ * `validators/view-config.schema.ts` (`filterStateSchema`, the strict capped
+ * variant for stored view config). The operator list in the describe text
+ * restates `filters/operators.ts` (`OPERATOR_SPECS`) and
+ * `filters/normalize-operator.ts` (`SYNONYM_ALIASES`) — those are the source
+ * of truth; keep the prose in sync when adding an operator.
+ */
+declare const filtersSchema: z.ZodObject<{
+    combinator: z.ZodDefault<z.ZodEnum<{
+        and: "and";
+        or: "or";
+    }>>;
+    rules: z.ZodArray<z.ZodObject<{
+        attribute: z.ZodString;
+        property: z.ZodOptional<z.ZodString>;
+        operator: z.ZodString;
+        value: z.ZodNullable<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const sortsSchema: z.ZodArray<z.ZodObject<{
+    attribute: z.ZodString;
+    direction: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>;
+}, z.core.$strip>>;
+/**
+ * Filter shapes derived from {@link filtersSchema} so the capability schema stays
+ * the single source of truth.
+ *
+ * The *parsed* shape (`z.infer`), deliberately: the runtime holds these after
+ * validation, when `combinator` has already been defaulted. What a caller may
+ * omit is `z.input`, and that is what {@link CapabilityInput} exposes.
+ */
+type FilterStateInput = z.infer<typeof filtersSchema>;
+type FilterRuleInput = FilterStateInput["rules"][number];
+/** How a capability mutates data, which decides whether a rehearsal captures it. */
+type CapabilityKind = "read" | "create" | "update" | "delete";
+/**
+ * Every capability a Reflex may call, defined once.
+ *
+ * Deliberately five entries — the single-record tools whose input the gateway can
+ * turn into a faithful `RunEffect`. Excluded on purpose: `get_schema`,
+ * `global_search` and `bulk_search`, which are not scoped to one object and so
+ * yield no object to grant a permission on; and the `bulk_*` record tools, where
+ * one call mutates many records and would be recorded as a single effect, making
+ * an effects report understate what happened.
+ *
+ * `description` is NOT here: the tools compute it per call from their config
+ * (`schemaInContext` changes the wording), and `schema-tools-descriptions.test.ts`
+ * pins both variants. The name, the kind and the input schema are what must exist
+ * exactly once, and they do.
+ */
+declare const RECORD_CAPABILITIES: {
+    readonly get_record: {
+        readonly name: "get_record";
+        readonly kind: "read";
+        readonly input: z.ZodObject<{
+            recordId: z.ZodString;
+            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    };
+    readonly search_records: {
+        readonly name: "search_records";
+        readonly kind: "read";
+        readonly input: z.ZodObject<{
+            objectId: z.ZodString;
+            _displayLabel: z.ZodOptional<z.ZodString>;
+            query: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            filters: z.ZodOptional<z.ZodObject<{
+                combinator: z.ZodDefault<z.ZodEnum<{
+                    and: "and";
+                    or: "or";
+                }>>;
+                rules: z.ZodArray<z.ZodObject<{
+                    attribute: z.ZodString;
+                    property: z.ZodOptional<z.ZodString>;
+                    operator: z.ZodString;
+                    value: z.ZodNullable<z.ZodUnknown>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            sorts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                attribute: z.ZodString;
+                direction: z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly create_record: {
+        readonly name: "create_record";
+        readonly kind: "create";
+        readonly input: z.ZodObject<{
+            objectId: z.ZodString;
+            _displayLabel: z.ZodOptional<z.ZodString>;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>;
+    };
+    readonly update_record: {
+        readonly name: "update_record";
+        readonly kind: "update";
+        readonly input: z.ZodObject<{
+            recordId: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>;
+    };
+    readonly delete_record: {
+        readonly name: "delete_record";
+        readonly kind: "delete";
+        readonly input: z.ZodObject<{
+            recordId: z.ZodString;
+        }, z.core.$strip>;
+    };
+};
+type RecordCapabilityName = keyof typeof RECORD_CAPABILITIES;
+/**
+ * A capability's argument type, inferred from the very schema the runtime
+ * validates against.
+ *
+ * `z.input`, not `z.infer`: these are the arguments a caller supplies, and the
+ * two sides differ wherever a field has a `.default()` — `filtersSchema`'s
+ * `combinator` is required on the output and optional on the input. Typing
+ * arguments with the output side made the SDK demand a `combinator` the runtime
+ * would have filled in anyway.
+ */
+type CapabilityInput<N extends RecordCapabilityName> = z.input<(typeof RECORD_CAPABILITIES)[N]["input"]>;
+/**
+ * The capability → kind projection, derived rather than restated. The reflexes
+ * module reads this instead of maintaining its own table (D26/D28).
+ */
+declare const RECORD_CAPABILITY_KINDS: Readonly<Record<RecordCapabilityName, CapabilityKind>>;
+
+export { type CapabilityInput, type CapabilityKind, type FilterRuleInput, type FilterStateInput, OBJECT_ID_DESCRIPTION, RECORD_CAPABILITIES, RECORD_CAPABILITY_KINDS, type RecordCapabilityName, SANDBOX_FILE_DATA_HINT, filtersSchema, sortsSchema };

package/dist/capabilities.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/capabilities.ts
+var OBJECT_ID_DESCRIPTION = "Object UUID, kebab-case name (e.g., 'contacts'), or display label (e.g., 'Personne physique'). All three are accepted; UUID is most precise.";
+var SANDBOX_FILE_DATA_HINT = ' For large text content (> a few KB), write it to a sandbox file first and pass {"$fromSandboxFile": "/workspace/<file>"} as the attribute value \u2014 the server substitutes the file content.';
+var filtersSchema = zod.z.object({
+  combinator: zod.z.enum(["and", "or"]).default("and"),
+  rules: zod.z.array(
+    zod.z.object({
+      attribute: zod.z.string().describe("Attribute name on the object being searched"),
+      property: zod.z.string().optional().describe(
+        "Optional. Only valid when 'attribute' is a relation / document / user attribute declared with .qualifyWith({...}). When set, the rule filters on the named EDGE property (not the linked record) and the operator must be valid for that property's type. See <filter_operators>."
+      ),
+      operator: zod.z.string().describe(
+        "Filter operator (canonical: is, is_not, contains, not_contains, starts_with, ends_with, less_than, greater_than, less_or_equal, greater_or_equal, is_within, on_day_month, any_of, none_of, is_empty, is_not_empty). Short codes (lt, gt, lte, gte, eq, neq, in) are accepted as input and auto-normalized to the canonical names. The valid set depends on the attribute type (or property type when 'property' is set) \u2014 see <filter_operators>."
+      ),
+      value: zod.z.unknown().nullable().describe(
+        "Value matching the attribute (or property) type: scalar for is/contains/less_than/etc (checkbox is: true|false); array (string[]) for any_of/none_of; null for is_empty/is_not_empty; { amount, unit, direction } for is_within; { day, month } for on_day_month."
+      )
+    })
+  )
+});
+var sortsSchema = zod.z.array(
+  zod.z.object({
+    attribute: zod.z.string().describe("Attribute name"),
+    direction: zod.z.enum(["asc", "desc"])
+  })
+);
+var getRecordInput = zod.z.object({
+  recordId: zod.z.string().describe("Record UUID"),
+  fields: zod.z.array(zod.z.string()).optional().describe("Attribute names to return")
+});
+var searchRecordsInput = zod.z.object({
+  objectId: zod.z.string().describe(OBJECT_ID_DESCRIPTION),
+  _displayLabel: zod.z.string().optional().describe("Display label"),
+  query: zod.z.string().optional().describe("Full-text search query (omit to browse/list)"),
+  limit: zod.z.number().optional().describe("Max results per call: 1-1000 (default 20). Paginate via offset for more."),
+  offset: zod.z.number().optional().describe("Skip N records (default 0)"),
+  fields: zod.z.array(zod.z.string()).optional().describe("Attribute names to include in values"),
+  filters: filtersSchema.optional().describe(
+    "Structured filter: { combinator: 'and'|'or', rules: [{attribute, operator, value, property?}] }. Operators are constrained per attribute type \u2014 see <filter_operators>. Use 'property' on a rule to filter on a qualified edge property."
+  ),
+  sorts: sortsSchema.optional().describe("Sorts: [{ attribute, direction: 'asc'|'desc' }]")
+});
+var createRecordInput = zod.z.object({
+  objectId: zod.z.string().describe(OBJECT_ID_DESCRIPTION),
+  _displayLabel: zod.z.string().optional().describe("Display label"),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).describe(`Record data.${SANDBOX_FILE_DATA_HINT}`)
+});
+var updateRecordInput = zod.z.object({
+  recordId: zod.z.string().describe("Record UUID"),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).describe(`Fields to update.${SANDBOX_FILE_DATA_HINT}`)
+});
+var deleteRecordInput = zod.z.object({
+  recordId: zod.z.string().describe("Record UUID")
+});
+var RECORD_CAPABILITIES = {
+  get_record: { name: "get_record", kind: "read", input: getRecordInput },
+  search_records: { name: "search_records", kind: "read", input: searchRecordsInput },
+  create_record: { name: "create_record", kind: "create", input: createRecordInput },
+  update_record: { name: "update_record", kind: "update", input: updateRecordInput },
+  delete_record: { name: "delete_record", kind: "delete", input: deleteRecordInput }
+};
+var RECORD_CAPABILITY_KINDS = Object.freeze(
+  Object.fromEntries(
+    Object.values(RECORD_CAPABILITIES).map((capability) => [capability.name, capability.kind])
+  )
+);
+
+exports.OBJECT_ID_DESCRIPTION = OBJECT_ID_DESCRIPTION;
+exports.RECORD_CAPABILITIES = RECORD_CAPABILITIES;
+exports.RECORD_CAPABILITY_KINDS = RECORD_CAPABILITY_KINDS;
+exports.SANDBOX_FILE_DATA_HINT = SANDBOX_FILE_DATA_HINT;
+exports.filtersSchema = filtersSchema;
+exports.sortsSchema = sortsSchema;

package/dist/capabilities.mjs

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+
+// src/capabilities.ts
+var OBJECT_ID_DESCRIPTION = "Object UUID, kebab-case name (e.g., 'contacts'), or display label (e.g., 'Personne physique'). All three are accepted; UUID is most precise.";
+var SANDBOX_FILE_DATA_HINT = ' For large text content (> a few KB), write it to a sandbox file first and pass {"$fromSandboxFile": "/workspace/<file>"} as the attribute value \u2014 the server substitutes the file content.';
+var filtersSchema = z.object({
+  combinator: z.enum(["and", "or"]).default("and"),
+  rules: z.array(
+    z.object({
+      attribute: z.string().describe("Attribute name on the object being searched"),
+      property: z.string().optional().describe(
+        "Optional. Only valid when 'attribute' is a relation / document / user attribute declared with .qualifyWith({...}). When set, the rule filters on the named EDGE property (not the linked record) and the operator must be valid for that property's type. See <filter_operators>."
+      ),
+      operator: z.string().describe(
+        "Filter operator (canonical: is, is_not, contains, not_contains, starts_with, ends_with, less_than, greater_than, less_or_equal, greater_or_equal, is_within, on_day_month, any_of, none_of, is_empty, is_not_empty). Short codes (lt, gt, lte, gte, eq, neq, in) are accepted as input and auto-normalized to the canonical names. The valid set depends on the attribute type (or property type when 'property' is set) \u2014 see <filter_operators>."
+      ),
+      value: z.unknown().nullable().describe(
+        "Value matching the attribute (or property) type: scalar for is/contains/less_than/etc (checkbox is: true|false); array (string[]) for any_of/none_of; null for is_empty/is_not_empty; { amount, unit, direction } for is_within; { day, month } for on_day_month."
+      )
+    })
+  )
+});
+var sortsSchema = z.array(
+  z.object({
+    attribute: z.string().describe("Attribute name"),
+    direction: z.enum(["asc", "desc"])
+  })
+);
+var getRecordInput = z.object({
+  recordId: z.string().describe("Record UUID"),
+  fields: z.array(z.string()).optional().describe("Attribute names to return")
+});
+var searchRecordsInput = z.object({
+  objectId: z.string().describe(OBJECT_ID_DESCRIPTION),
+  _displayLabel: z.string().optional().describe("Display label"),
+  query: z.string().optional().describe("Full-text search query (omit to browse/list)"),
+  limit: z.number().optional().describe("Max results per call: 1-1000 (default 20). Paginate via offset for more."),
+  offset: z.number().optional().describe("Skip N records (default 0)"),
+  fields: z.array(z.string()).optional().describe("Attribute names to include in values"),
+  filters: filtersSchema.optional().describe(
+    "Structured filter: { combinator: 'and'|'or', rules: [{attribute, operator, value, property?}] }. Operators are constrained per attribute type \u2014 see <filter_operators>. Use 'property' on a rule to filter on a qualified edge property."
+  ),
+  sorts: sortsSchema.optional().describe("Sorts: [{ attribute, direction: 'asc'|'desc' }]")
+});
+var createRecordInput = z.object({
+  objectId: z.string().describe(OBJECT_ID_DESCRIPTION),
+  _displayLabel: z.string().optional().describe("Display label"),
+  data: z.record(z.string(), z.unknown()).describe(`Record data.${SANDBOX_FILE_DATA_HINT}`)
+});
+var updateRecordInput = z.object({
+  recordId: z.string().describe("Record UUID"),
+  data: z.record(z.string(), z.unknown()).describe(`Fields to update.${SANDBOX_FILE_DATA_HINT}`)
+});
+var deleteRecordInput = z.object({
+  recordId: z.string().describe("Record UUID")
+});
+var RECORD_CAPABILITIES = {
+  get_record: { name: "get_record", kind: "read", input: getRecordInput },
+  search_records: { name: "search_records", kind: "read", input: searchRecordsInput },
+  create_record: { name: "create_record", kind: "create", input: createRecordInput },
+  update_record: { name: "update_record", kind: "update", input: updateRecordInput },
+  delete_record: { name: "delete_record", kind: "delete", input: deleteRecordInput }
+};
+var RECORD_CAPABILITY_KINDS = Object.freeze(
+  Object.fromEntries(
+    Object.values(RECORD_CAPABILITIES).map((capability) => [capability.name, capability.kind])
+  )
+);
+
+export { OBJECT_ID_DESCRIPTION, RECORD_CAPABILITIES, RECORD_CAPABILITY_KINDS, SANDBOX_FILE_DATA_HINT, filtersSchema, sortsSchema };

package/dist/{chunk-R34LOMT7.mjs → chunk-5OBQRDRM.mjs}

@@ -1,4 +1,4 @@
-import { ValidationError } from './chunk-HOVUEYEQ.mjs';
+import { ValidationError } from './chunk-RUO25ERR.mjs';
 import { z } from 'zod';
 import { ICONS, COLORS } from '@stndrds/constants';
 
@@ -549,7 +549,7 @@ var attributeConfigSchemas = {
 function getAttributeConfigSchema(type) {
   const schema = attributeConfigSchemas[type];
   if (!schema) {
-    throw new Error(`Unsupported attribute type: ${type}`);
+    throw new ValidationError(`Unsupported attribute type: ${type}`, []);
   }
   return schema;
 }
@@ -638,4 +638,4 @@ function parseAttributeConfigForUpdate(stored, patch) {
   return parsed;
 }
 
-export { ComputedFormulaParseError, SCHEMA_LIMITS, attributeConfigSchemas, colorIdSchema, getAttributeConfigSchema, iconNameSchema, multiselectOptionWriteSchema, parseAttributeConfig, parseAttributeConfigForCreate, parseAttributeConfigForUpdate, parseComputedFormula, selectOptionWriteSchema, statusGroupSchema, statusOptionWriteSchema };
+export { ComputedFormulaParseError, SCHEMA_LIMITS, attributeConfigSchemas, colorIdSchema, getAttributeConfigSchema, getAttributeConfigWriteSchema, iconNameSchema, multiselectOptionWriteSchema, parseAttributeConfig, parseAttributeConfigForCreate, parseAttributeConfigForUpdate, parseComputedFormula, selectOptionWriteSchema, statusGroupSchema, statusOptionWriteSchema };

package/dist/{chunk-QGRYOIHT.mjs → chunk-AGRAFDGU.mjs}

@@ -1,5 +1,5 @@
-import { SCHEMA_LIMITS, iconNameSchema } from './chunk-R34LOMT7.mjs';
-import { ValidationError } from './chunk-HOVUEYEQ.mjs';
+import { SCHEMA_LIMITS, iconNameSchema } from './chunk-5OBQRDRM.mjs';
+import { ValidationError } from './chunk-RUO25ERR.mjs';
 import { z } from 'zod';
 
 // src/types/system-attributes.ts
@@ -959,20 +959,25 @@ var fieldPresentationShape = {
   label: z.string().optional(),
   readOnly: z.boolean().optional()
 };
-var fieldSchema = z.object({
-  /** Stable slot identity. Optional: a builder may omit it, `ensureFieldIds` assigns it. */
-  id: z.string().optional(),
+var fieldShape = {
   attribute: z.string().optional(),
   attributeGroup: attributeGroupFieldSchema.optional(),
   ...fieldPresentationShape
-}).strict().superRefine((field, ctx) => {
+};
+function refineField(field, ctx) {
   if (field.attribute === void 0 === (field.attributeGroup === void 0)) {
     ctx.addIssue({
       code: "custom",
       message: "A field must define exactly one of attribute or attributeGroup"
     });
   }
-});
+}
+var fieldSchema = z.object({
+  /** Stable slot identity. Optional: a builder may omit it, `ensureFieldIds` assigns it. */
+  id: z.string().optional(),
+  ...fieldShape
+}).strict().superRefine(refineField);
+var fieldSlotSchema = z.object({ id: z.string().min(1), ...fieldShape }).strict().superRefine(refineField);
 var baseGroupShape = {
   id: z.string(),
   label: z.string(),
@@ -994,13 +999,16 @@ var baseTabShape = {
   icon: iconNameSchema.optional(),
   order: z.number().optional()
 };
-var formTabWriteSchema = z.object({
+var formTabGroupsSchema = z.array(groupWriteSchema).max(SCHEMA_LIMITS.groupsPerFormTab);
+var formTabShape = {
   ...baseTabShape,
   type: z.literal("form"),
-  groups: z.array(groupWriteSchema).min(1).max(SCHEMA_LIMITS.groupsPerFormTab),
+  groups: formTabGroupsSchema,
   formColumns: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional(),
   density: z.enum(["compact", "comfortable", "spacious"]).optional()
-}).strict().superRefine((tab, ctx) => {
+};
+var formTabDraftObjectSchema = z.object(formTabShape).strict();
+function refineFormTab(tab, ctx) {
   addDuplicateIdIssues(tab.groups, ctx, ["groups"]);
   const totalFields = tab.groups.reduce(
     (count, group) => count + (group.type === "fields" ? group.fields.length : 0),
@@ -1032,7 +1040,9 @@ var formTabWriteSchema = z.object({
       seenAttributeGroupIds.add(id);
     });
   });
-});
+}
+var formTabWriteSchema = z.object({ ...formTabShape, groups: formTabGroupsSchema.min(1) }).strict().superRefine(refineFormTab);
+var formTabDraftSchema = formTabDraftObjectSchema.superRefine(refineFormTab);
 var relationSourceSchema = z.object({
   type: z.literal("relation"),
   attribute: z.string()
@@ -1221,8 +1231,7 @@ var meetingsTabSchema = z.object({
   type: z.literal("meetings"),
   emailAttributeIds: z.array(z.string()).max(SCHEMA_LIMITS.emailAttributesPerTab)
 }).strict();
-var detailTabSchema = z.discriminatedUnion("type", [
-  formTabWriteSchema,
+var nonFormDetailTabSchemas = [
   tableTabSchema,
   customTabSchema,
   activityTabSchema,
@@ -1231,6 +1240,14 @@ var detailTabSchema = z.discriminatedUnion("type", [
   formsTabSchema,
   emailsTabSchema,
   meetingsTabSchema
+];
+var detailTabSchema = z.discriminatedUnion("type", [
+  formTabWriteSchema,
+  ...nonFormDetailTabSchemas
+]);
+var detailTabDraftSchema = z.discriminatedUnion("type", [
+  formTabDraftSchema,
+  ...nonFormDetailTabSchemas
 ]);
 var listTabCommonShape = {
   id: z.string(),
@@ -1348,5 +1365,14 @@ function parseViewConfig(type, input) {
       return viewConfigByTypeSchema.parse({ type, config: input }).config;
   }
 }
+var LIST_TAB_TABLE_KEYS = ["columnSizing"];
+var LIST_TAB_KANBAN_KEYS = [
+  "groupByAttribute",
+  "cardUserAttribute",
+  "cardDateAttribute",
+  "kanbanColumnOrder",
+  "kanbanColumnVisibility",
+  "kanbanPinnedColumns"
+];
 
-export { ATTRIBUTE_FILTER_OPERATORS, LIST_VIEW_TAB_VISIBILITIES, NO_VALUE_OPERATORS, OPERATORS_BY_TYPE, REMOVED_OPERATOR_REPLACEMENTS, RESERVED_ATTRIBUTE_NAMES, RESERVED_OBJECT_NAMES, RESOURCE_VISIBILITIES, SYNONYM_ALIASES, SYSTEM_ATTRIBUTES, SYSTEM_ATTRIBUTE_I18N_KEYS, SYSTEM_FIELD_NAMES, SYSTEM_FILTER_ATTRIBUTE_TYPES, canonicalizeFilterValue, collectQualifiedRuleIssues, currentActor, detailTabSchema, detailViewConfigSchema, extractCurrencyFilterValue, extractFilterValue, getAttributeCapabilities, getAttributeFilterOperators, getOperatorPolarity, getRollupFilterOperators2 as getRollupFilterOperators, getSystemAttributeI18nKey, getSystemAttributeList, inverseSourceSchema, isAttributeFilterable, isAttributeGroupable, isAttributeKanbanGroupable, isAttributeSearchable, isAttributeSortable, isDynamicValue, isManagedSystemAttribute, isNoValueOperator, isRelativeDateValue, isSetMembershipOperator, listViewConfigSchema, listViewTabSchema, normalizeFilterRule, normalizeForEdgeRpc, normalizeOperator, now, parseResourceVisibility, parseViewConfig, relationSourceSchema, resolveEffectiveFilterType, resolveIsWithinBounds, resolveUtcDayBounds, tableSourceSchema, toMultiValueOperator, toUtcDayString, today, validateQualifiedRule, viewConfigByTypeSchema, viewTypeSchema };
+export { ATTRIBUTE_FILTER_OPERATORS, LIST_TAB_KANBAN_KEYS, LIST_TAB_TABLE_KEYS, LIST_VIEW_TAB_VISIBILITIES, NO_VALUE_OPERATORS, OPERATORS_BY_TYPE, REMOVED_OPERATOR_REPLACEMENTS, RESERVED_ATTRIBUTE_NAMES, RESERVED_OBJECT_NAMES, RESOURCE_VISIBILITIES, SYNONYM_ALIASES, SYSTEM_ATTRIBUTES, SYSTEM_ATTRIBUTE_I18N_KEYS, SYSTEM_FIELD_NAMES, SYSTEM_FILTER_ATTRIBUTE_TYPES, canonicalizeFilterValue, collectQualifiedRuleIssues, columnsSchema, currentActor, detailTabDraftSchema, detailTabSchema, detailViewConfigSchema, extractCurrencyFilterValue, extractFilterValue, fieldSchema, fieldShape, fieldSlotSchema, filterGroupSchema, filterStateSchema, getAttributeCapabilities, getAttributeFilterOperators, getOperatorPolarity, getRollupFilterOperators2 as getRollupFilterOperators, getSystemAttributeI18nKey, getSystemAttributeList, groupWriteSchema, inverseSourceSchema, isAttributeFilterable, isAttributeGroupable, isAttributeKanbanGroupable, isAttributeSearchable, isAttributeSortable, isDynamicValue, isManagedSystemAttribute, isNoValueOperator, isRelativeDateValue, isSetMembershipOperator, listViewConfigSchema, listViewTabSchema, normalizeFilterRule, normalizeForEdgeRpc, normalizeOperator, now, parseResourceVisibility, parseViewConfig, relationSourceSchema, resolveEffectiveFilterType, resolveIsWithinBounds, resolveUtcDayBounds, sortsSchema, tableSourceSchema, toMultiValueOperator, toUtcDayString, today, validateQualifiedRule, viewConfigByTypeSchema, viewTypeSchema };