@stndrds/schema 1.0.0-alpha.281 → 1.0.0-alpha.284

package/dist/{chunk-TU6ECJFZ.js → chunk-YZ5RCMIQ.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkLRFLSFIA_js = require('./chunk-LRFLSFIA.js');
-var chunkHWZRSXFB_js = require('./chunk-HWZRSXFB.js');
+var chunkBOICAZHR_js = require('./chunk-BOICAZHR.js');
+var chunkV26R64A4_js = require('./chunk-V26R64A4.js');
 var zod = require('zod');
 
 // src/types/system-attributes.ts
@@ -500,7 +500,7 @@ function canonicalizeFilterValue(rule, effectiveType) {
   const message = `Filter on a currency attribute expected a numeric amount, received ${JSON.stringify(
     value
   )}`;
-  throw new chunkHWZRSXFB_js.ValidationError(message, [{ path: ["value"], message }]);
+  throw new chunkV26R64A4_js.ValidationError(message, [{ path: ["value"], message }]);
 }
 function hasCurrencyAmount(value) {
   if (typeof value !== "object") return true;
@@ -661,13 +661,13 @@ function resolveCanonicalOperator(rawOperator, effectiveType) {
   const replacement = REMOVED_OPERATOR_REPLACEMENTS[rawOperator];
   if (replacement) {
     const m = `Unknown filter operator "${rawOperator}" \u2014 use ${replacement}`;
-    throw new chunkHWZRSXFB_js.ValidationError(m, [{ path: ["operator"], message: m }]);
+    throw new chunkV26R64A4_js.ValidationError(m, [{ path: ["operator"], message: m }]);
   }
   const normalized = normalizeOperator(rawOperator);
   const membership = SUBSTRING_TO_MEMBERSHIP[normalized];
   if (membership && SET_MEMBERSHIP_TYPES.has(effectiveType)) {
     const m = `Operator "${normalized}" is not valid for type "${effectiveType}" \u2014 use "${membership}"`;
-    throw new chunkHWZRSXFB_js.ValidationError(m, [{ path: ["operator"], message: m }]);
+    throw new chunkV26R64A4_js.ValidationError(m, [{ path: ["operator"], message: m }]);
   }
   return normalized;
 }
@@ -677,7 +677,7 @@ function assertOperatorForType(operator, type, context) {
   if (!ops?.includes(normalized)) {
     const validList = ops?.length ? ops.join(", ") : "(no operators registered for this type)";
     const summary = `Operator "${operator}" is not valid for ${context} type "${type}". Valid operators: ${validList}.`;
-    throw new chunkHWZRSXFB_js.ValidationError(summary, [
+    throw new chunkV26R64A4_js.ValidationError(summary, [
       {
         path: ["operator"],
         message: summary
@@ -690,7 +690,7 @@ function assertRelativeDateValue(rule) {
   if (rule.operator !== "is_within") return;
   if (!isRelativeDateValue(rule.value)) {
     const m = `Operator "is_within" requires a relative-date value { amount: positive number, unit: days|weeks|months|years, direction: past|future }`;
-    throw new chunkHWZRSXFB_js.ValidationError(m, [{ path: ["value"], message: m }]);
+    throw new chunkV26R64A4_js.ValidationError(m, [{ path: ["value"], message: m }]);
   }
 }
 function applyCanonicalForm(rule, operator, effectiveType) {
@@ -703,11 +703,11 @@ function assertDynamicValueForAttribute(rule, attrType) {
   const v = rule.value;
   if (v.dynamic === "actor" && attrType !== "user") {
     const m = `actor token (@me) is only valid on user attributes, not "${attrType}"`;
-    throw new chunkHWZRSXFB_js.ValidationError(m, [{ path: ["value"], message: m }]);
+    throw new chunkV26R64A4_js.ValidationError(m, [{ path: ["value"], message: m }]);
   }
   if (v.dynamic === "date" && attrType !== "date") {
     const m = `date token (@today/@now) is only valid on date attributes, not "${attrType}"`;
-    throw new chunkHWZRSXFB_js.ValidationError(m, [{ path: ["value"], message: m }]);
+    throw new chunkV26R64A4_js.ValidationError(m, [{ path: ["value"], message: m }]);
   }
 }
 function collectQualifiedRuleIssues(rule, context) {
@@ -715,7 +715,7 @@ function collectQualifiedRuleIssues(rule, context) {
     validateQualifiedRule({ ...rule }, context);
     return [];
   } catch (error) {
-    if (!(error instanceof chunkHWZRSXFB_js.ValidationError)) throw error;
+    if (!(error instanceof chunkV26R64A4_js.ValidationError)) throw error;
     return error.errors.map((issue) => ({ ...issue, path: [...issue.path] }));
   }
 }
@@ -723,17 +723,17 @@ function validateQualifiedRule(rule, context) {
   const rootAttr = context.attributes.find((a) => a.name === rule.attribute);
   const systemOps = SYSTEM_FILTER_OPERATORS[rule.attribute];
   if (!(rootAttr || systemOps)) {
-    throw new chunkHWZRSXFB_js.ValidationError(`Unknown attribute: ${rule.attribute}`, [
+    throw new chunkV26R64A4_js.ValidationError(`Unknown attribute: ${rule.attribute}`, [
       { path: ["attribute"], message: `Unknown attribute: ${rule.attribute}` }
     ]);
   }
   if (rule.quantifier !== void 0 && !rule.property) {
     const m = `quantifier is only valid on qualified edge rules (set "property")`;
-    throw new chunkHWZRSXFB_js.ValidationError(m, [{ path: ["quantifier"], message: m }]);
+    throw new chunkV26R64A4_js.ValidationError(m, [{ path: ["quantifier"], message: m }]);
   }
   if (!rootAttr) {
     if (rule.property) {
-      throw new chunkHWZRSXFB_js.ValidationError(`Cannot qualify system attribute "${rule.attribute}"`, [
+      throw new chunkV26R64A4_js.ValidationError(`Cannot qualify system attribute "${rule.attribute}"`, [
         { path: ["property"], message: `"${rule.attribute}" is a system column, not a reference` }
       ]);
     }
@@ -741,7 +741,7 @@ function validateQualifiedRule(rule, context) {
     const normalizedOperator2 = resolveCanonicalOperator(rule.operator, effectiveType);
     if (!systemOps.includes(normalizedOperator2)) {
       const summary = `Operator "${rule.operator}" is not valid for system attribute "${rule.attribute}". Valid operators: ${systemOps.join(", ")}.`;
-      throw new chunkHWZRSXFB_js.ValidationError(summary, [{ path: ["operator"], message: summary }]);
+      throw new chunkV26R64A4_js.ValidationError(summary, [{ path: ["operator"], message: summary }]);
     }
     applyCanonicalForm(rule, normalizedOperator2, effectiveType);
     return;
@@ -753,25 +753,25 @@ function validateQualifiedRule(rule, context) {
     if (!ops.includes(normalizedOperator2)) {
       const validList = ops.length ? ops.join(", ") : "(not filterable)";
       const summary = `Operator "${rule.operator}" is not valid for attribute "${rootAttr.name}". Valid operators: ${validList}.`;
-      throw new chunkHWZRSXFB_js.ValidationError(summary, [{ path: ["operator"], message: summary }]);
+      throw new chunkV26R64A4_js.ValidationError(summary, [{ path: ["operator"], message: summary }]);
     }
     applyCanonicalForm(rule, normalizedOperator2, resolveEffectiveFilterType(rootAttr));
     return;
   }
   if (!REFERENCE_TYPES.has(rootAttr.type)) {
-    throw new chunkHWZRSXFB_js.ValidationError(`Cannot qualify ${rootAttr.type} attribute "${rule.attribute}"`, [
+    throw new chunkV26R64A4_js.ValidationError(`Cannot qualify ${rootAttr.type} attribute "${rule.attribute}"`, [
       { path: ["property"], message: `Attribute "${rule.attribute}" is not a reference type` }
     ]);
   }
   const propSchema = rootAttr.properties;
   if (!propSchema) {
-    throw new chunkHWZRSXFB_js.ValidationError(`Attribute "${rule.attribute}" has no qualifyWith schema`, [
+    throw new chunkV26R64A4_js.ValidationError(`Attribute "${rule.attribute}" has no qualifyWith schema`, [
       { path: ["property"], message: `"${rule.attribute}" has no qualifyWith` }
     ]);
   }
   const propDef = propSchema.definitions.find((p) => p.name === rule.property);
   if (!propDef) {
-    throw new chunkHWZRSXFB_js.ValidationError(
+    throw new chunkV26R64A4_js.ValidationError(
       `Property "${rule.property}" not defined on "${rule.attribute}".qualifyWith()`,
       [{ path: ["property"], message: `Unknown property: ${rule.property}` }]
     );
@@ -787,7 +787,7 @@ function parseResourceVisibility(value) {
   if (typeof value === "string" && RESOURCE_VISIBILITIES.includes(value)) {
     return value;
   }
-  throw new chunkHWZRSXFB_js.ValidationError(
+  throw new chunkV26R64A4_js.ValidationError(
     `visibility must be one of: ${RESOURCE_VISIBILITIES.join(", ")} (received: ${String(value)})`,
     []
   );
@@ -821,12 +821,12 @@ var RESERVED_OBJECT_NAMES = ["skill"];
 // src/validators/view-config.schema.ts
 var createModeSchema = zod.z.enum(["redirect", "inline", "peek"]);
 var nonEmptyStringArraySchema = zod.z.array(zod.z.string()).min(1);
-var columnsSchema = zod.z.array(zod.z.string()).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.columnsPerTab);
+var columnsSchema = zod.z.array(zod.z.string()).max(chunkBOICAZHR_js.SCHEMA_LIMITS.columnsPerTab);
 var sortRuleSchema = zod.z.object({
   attribute: zod.z.string(),
   direction: zod.z.enum(["asc", "desc"])
 }).strict();
-var sortsSchema = zod.z.array(sortRuleSchema).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.sortsPerTab);
+var sortsSchema = zod.z.array(sortRuleSchema).max(chunkBOICAZHR_js.SCHEMA_LIMITS.sortsPerTab);
 var relativeDateValueSchema = zod.z.object({
   amount: zod.z.number(),
   unit: zod.z.enum(["days", "weeks", "months", "years"]),
@@ -900,7 +900,7 @@ var filterRuleSchema = zod.z.object({
   operator: filterOperatorSchema,
   value: filterValueSchema
 }).strict();
-var filterRulesSchema = zod.z.array(filterRuleSchema).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.filterRulesPerTab);
+var filterRulesSchema = zod.z.array(filterRuleSchema).max(chunkBOICAZHR_js.SCHEMA_LIMITS.filterRulesPerTab);
 var filterStateSchema = zod.z.object({
   combinator: zod.z.enum(["and", "or"]),
   rules: filterRulesSchema
@@ -961,20 +961,25 @@ var fieldPresentationShape = {
   label: zod.z.string().optional(),
   readOnly: zod.z.boolean().optional()
 };
-var fieldSchema = zod.z.object({
-  /** Stable slot identity. Optional: a builder may omit it, `ensureFieldIds` assigns it. */
-  id: zod.z.string().optional(),
+var fieldShape = {
   attribute: zod.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 = zod.z.object({
+  /** Stable slot identity. Optional: a builder may omit it, `ensureFieldIds` assigns it. */
+  id: zod.z.string().optional(),
+  ...fieldShape
+}).strict().superRefine(refineField);
+var fieldSlotSchema = zod.z.object({ id: zod.z.string().min(1), ...fieldShape }).strict().superRefine(refineField);
 var baseGroupShape = {
   id: zod.z.string(),
   label: zod.z.string(),
@@ -986,35 +991,38 @@ var baseGroupShape = {
 var fieldGroupWriteSchema = zod.z.object({
   ...baseGroupShape,
   type: zod.z.literal("fields"),
-  fields: zod.z.array(fieldSchema).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.fieldsPerGroup)
+  fields: zod.z.array(fieldSchema).max(chunkBOICAZHR_js.SCHEMA_LIMITS.fieldsPerGroup)
 }).strict();
 var groupWriteSchema = fieldGroupWriteSchema;
 var baseTabShape = {
   id: zod.z.string(),
   name: zod.z.string(),
   label: zod.z.string(),
-  icon: chunkLRFLSFIA_js.iconNameSchema.optional(),
+  icon: chunkBOICAZHR_js.iconNameSchema.optional(),
   order: zod.z.number().optional()
 };
-var formTabWriteSchema = zod.z.object({
+var formTabGroupsSchema = zod.z.array(groupWriteSchema).max(chunkBOICAZHR_js.SCHEMA_LIMITS.groupsPerFormTab);
+var formTabShape = {
   ...baseTabShape,
   type: zod.z.literal("form"),
-  groups: zod.z.array(groupWriteSchema).min(1).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.groupsPerFormTab),
+  groups: formTabGroupsSchema,
   formColumns: zod.z.union([zod.z.literal(1), zod.z.literal(2), zod.z.literal(3)]).optional(),
   density: zod.z.enum(["compact", "comfortable", "spacious"]).optional()
-}).strict().superRefine((tab, ctx) => {
+};
+var formTabDraftObjectSchema = zod.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),
     0
   );
-  if (totalFields > chunkLRFLSFIA_js.SCHEMA_LIMITS.fieldsPerFormTab) {
+  if (totalFields > chunkBOICAZHR_js.SCHEMA_LIMITS.fieldsPerFormTab) {
     ctx.addIssue({
       code: "too_big",
       origin: "array",
-      maximum: chunkLRFLSFIA_js.SCHEMA_LIMITS.fieldsPerFormTab,
+      maximum: chunkBOICAZHR_js.SCHEMA_LIMITS.fieldsPerFormTab,
       inclusive: true,
-      message: `A form tab can contain at most ${chunkLRFLSFIA_js.SCHEMA_LIMITS.fieldsPerFormTab} fields`,
+      message: `A form tab can contain at most ${chunkBOICAZHR_js.SCHEMA_LIMITS.fieldsPerFormTab} fields`,
       path: ["groups"]
     });
   }
@@ -1034,7 +1042,9 @@ var formTabWriteSchema = zod.z.object({
       seenAttributeGroupIds.add(id);
     });
   });
-});
+}
+var formTabWriteSchema = zod.z.object({ ...formTabShape, groups: formTabGroupsSchema.min(1) }).strict().superRefine(refineFormTab);
+var formTabDraftSchema = formTabDraftObjectSchema.superRefine(refineFormTab);
 var relationSourceSchema = zod.z.object({
   type: zod.z.literal("relation"),
   attribute: zod.z.string()
@@ -1216,15 +1226,14 @@ var formsTabSchema = zod.z.object({
 var emailsTabSchema = zod.z.object({
   ...baseTabShape,
   type: zod.z.literal("emails"),
-  emailAttributeIds: zod.z.array(zod.z.string()).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.emailAttributesPerTab)
+  emailAttributeIds: zod.z.array(zod.z.string()).max(chunkBOICAZHR_js.SCHEMA_LIMITS.emailAttributesPerTab)
 }).strict();
 var meetingsTabSchema = zod.z.object({
   ...baseTabShape,
   type: zod.z.literal("meetings"),
-  emailAttributeIds: zod.z.array(zod.z.string()).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.emailAttributesPerTab)
+  emailAttributeIds: zod.z.array(zod.z.string()).max(chunkBOICAZHR_js.SCHEMA_LIMITS.emailAttributesPerTab)
 }).strict();
-var detailTabSchema = zod.z.discriminatedUnion("type", [
-  formTabWriteSchema,
+var nonFormDetailTabSchemas = [
   tableTabSchema,
   customTabSchema,
   activityTabSchema,
@@ -1233,11 +1242,19 @@ var detailTabSchema = zod.z.discriminatedUnion("type", [
   formsTabSchema,
   emailsTabSchema,
   meetingsTabSchema
+];
+var detailTabSchema = zod.z.discriminatedUnion("type", [
+  formTabWriteSchema,
+  ...nonFormDetailTabSchemas
+]);
+var detailTabDraftSchema = zod.z.discriminatedUnion("type", [
+  formTabDraftSchema,
+  ...nonFormDetailTabSchemas
 ]);
 var listTabCommonShape = {
   id: zod.z.string(),
   label: zod.z.string(),
-  icon: chunkLRFLSFIA_js.iconNameSchema.optional(),
+  icon: chunkBOICAZHR_js.iconNameSchema.optional(),
   default: zod.z.boolean().optional(),
   // Which records the tab scopes to. `"all"` is the default and means "impose
   // no scope" — the mandatory viewer predicate alone decides, so the tab shows
@@ -1271,7 +1288,7 @@ var listViewTabSchema = zod.z.discriminatedUnion("layout", [
 ]);
 var _listViewConfigSchema = zod.z.object({
   defaultFilters: filterGroupSchema.optional(),
-  tabs: zod.z.array(listViewTabSchema).min(1).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.tabsPerView)
+  tabs: zod.z.array(listViewTabSchema).min(1).max(chunkBOICAZHR_js.SCHEMA_LIMITS.tabsPerView)
 }).strict().superRefine((config, ctx) => {
   addDuplicateIdIssues(config.tabs, ctx, ["tabs"]);
   let hasDefault = false;
@@ -1287,12 +1304,42 @@ var _listViewConfigSchema = zod.z.object({
     hasDefault = true;
   });
 });
+var sidePanelPaneSchema = zod.z.discriminatedUnion("kind", [
+  zod.z.object({
+    kind: zod.z.literal("fields"),
+    id: zod.z.string().optional(),
+    label: zod.z.string().optional(),
+    attributes: zod.z.array(zod.z.string()).max(chunkBOICAZHR_js.SCHEMA_LIMITS.sidePanelAttributes)
+  }).strict(),
+  zod.z.object({
+    kind: zod.z.literal("activity"),
+    id: zod.z.string().optional(),
+    label: zod.z.string().optional()
+  }).strict(),
+  zod.z.object({
+    kind: zod.z.literal("documents"),
+    // Required here alone: the documents content keys its stored sort mode
+    // on this id, so a pane without one would share the main-column
+    // documents tab's sort.
+    id: zod.z.string(),
+    label: zod.z.string().optional(),
+    allowUpload: zod.z.boolean().optional(),
+    allowRemove: zod.z.boolean().optional()
+  }).strict()
+]);
 var _detailViewConfigSchema = zod.z.object({
-  tabs: zod.z.array(detailTabSchema).min(1).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.tabsPerView),
+  tabs: zod.z.array(detailTabSchema).min(1).max(chunkBOICAZHR_js.SCHEMA_LIMITS.tabsPerView),
   sidePanel: zod.z.object({
-    attributes: zod.z.array(zod.z.string()).max(chunkLRFLSFIA_js.SCHEMA_LIMITS.sidePanelAttributes),
+    attributes: zod.z.array(zod.z.string()).max(chunkBOICAZHR_js.SCHEMA_LIMITS.sidePanelAttributes).optional(),
+    panes: zod.z.array(sidePanelPaneSchema).max(chunkBOICAZHR_js.SCHEMA_LIMITS.sidePanelPanes).optional(),
     width: zod.z.number().optional()
-  }).strict().optional()
+  }).strict().refine((sidePanel) => sidePanel.attributes !== void 0 || sidePanel.panes !== void 0, {
+    message: "sidePanel requires attributes or panes"
+  }).refine((sidePanel) => sidePanel.panes === void 0 || sidePanel.panes.length > 0, {
+    message: "sidePanel panes must not be empty"
+  }).refine((sidePanel) => sidePanel.attributes === void 0 || sidePanel.panes === void 0, {
+    message: "sidePanel takes attributes or panes, not both"
+  }).optional()
 }).strict().superRefine((config, ctx) => {
   addDuplicateIdIssues(config.tabs, ctx, ["tabs"]);
   addDuplicateNameIssues(config.tabs, ctx, ["tabs"]);
@@ -1320,8 +1367,19 @@ 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"
+];
 
 exports.ATTRIBUTE_FILTER_OPERATORS = ATTRIBUTE_FILTER_OPERATORS;
+exports.LIST_TAB_KANBAN_KEYS = LIST_TAB_KANBAN_KEYS;
+exports.LIST_TAB_TABLE_KEYS = LIST_TAB_TABLE_KEYS;
 exports.LIST_VIEW_TAB_VISIBILITIES = LIST_VIEW_TAB_VISIBILITIES;
 exports.NO_VALUE_OPERATORS = NO_VALUE_OPERATORS;
 exports.OPERATORS_BY_TYPE = OPERATORS_BY_TYPE;
@@ -1336,17 +1394,25 @@ exports.SYSTEM_FIELD_NAMES = SYSTEM_FIELD_NAMES;
 exports.SYSTEM_FILTER_ATTRIBUTE_TYPES = SYSTEM_FILTER_ATTRIBUTE_TYPES;
 exports.canonicalizeFilterValue = canonicalizeFilterValue;
 exports.collectQualifiedRuleIssues = collectQualifiedRuleIssues;
+exports.columnsSchema = columnsSchema;
 exports.currentActor = currentActor;
+exports.detailTabDraftSchema = detailTabDraftSchema;
 exports.detailTabSchema = detailTabSchema;
 exports.detailViewConfigSchema = detailViewConfigSchema;
 exports.extractCurrencyFilterValue = extractCurrencyFilterValue;
 exports.extractFilterValue = extractFilterValue;
+exports.fieldSchema = fieldSchema;
+exports.fieldShape = fieldShape;
+exports.fieldSlotSchema = fieldSlotSchema;
+exports.filterGroupSchema = filterGroupSchema;
+exports.filterStateSchema = filterStateSchema;
 exports.getAttributeCapabilities = getAttributeCapabilities;
 exports.getAttributeFilterOperators = getAttributeFilterOperators;
 exports.getOperatorPolarity = getOperatorPolarity;
 exports.getRollupFilterOperators = getRollupFilterOperators2;
 exports.getSystemAttributeI18nKey = getSystemAttributeI18nKey;
 exports.getSystemAttributeList = getSystemAttributeList;
+exports.groupWriteSchema = groupWriteSchema;
 exports.inverseSourceSchema = inverseSourceSchema;
 exports.isAttributeFilterable = isAttributeFilterable;
 exports.isAttributeGroupable = isAttributeGroupable;
@@ -1370,6 +1436,7 @@ exports.relationSourceSchema = relationSourceSchema;
 exports.resolveEffectiveFilterType = resolveEffectiveFilterType;
 exports.resolveIsWithinBounds = resolveIsWithinBounds;
 exports.resolveUtcDayBounds = resolveUtcDayBounds;
+exports.sortsSchema = sortsSchema;
 exports.tableSourceSchema = tableSourceSchema;
 exports.toMultiValueOperator = toMultiValueOperator;
 exports.toUtcDayString = toUtcDayString;

package/dist/exceptions.d.mts

@@ -1,5 +1,5 @@
-import { S as SchemaOperation } from './migrations-BNlQVzDC.mjs';
-import './attributes--M1ifW8_.mjs';
+import { S as SchemaOperation } from './migrations-fRvadl6i.mjs';
+import './attributes-CWPLbp7c.mjs';
 import '@stndrds/constants';
 import './utils.mjs';
 
@@ -23,6 +23,19 @@ declare const SchemaErrorCode: {
     readonly PROTECTED_ROLE: "SCHEMA_PROTECTED_ROLE";
     readonly FORBIDDEN: "SCHEMA_FORBIDDEN";
     readonly ACCESS_DENIED: "SCHEMA_ACCESS_DENIED";
+    /**
+     * A workspace RULE refuses the write — the last owner cannot be removed.
+     *
+     * Not `INVARIANT_VIOLATION`, despite the name: that one is an internal
+     * "should never happen" assertion, a bug signal nobody outside the codebase
+     * can act on. This is the opposite — a rule the caller can act on, reached
+     * by a request that was entirely well-formed, whose message tells them how.
+     */
+    readonly WORKSPACE_INVARIANT: "SCHEMA_WORKSPACE_INVARIANT";
+    /** The resource's own state refuses the operation — a disarmed reflex run. */
+    readonly STATE_GATE: "SCHEMA_STATE_GATE";
+    /** The operation needs an actor and the request carried none. */
+    readonly ACTOR_CONTEXT_REQUIRED: "SCHEMA_ACTOR_CONTEXT_REQUIRED";
     readonly CONNECTOR_AUTH_FAILED: "SCHEMA_CONNECTOR_AUTH_FAILED";
     readonly CONNECTOR_INVALID_STATE: "SCHEMA_CONNECTOR_INVALID_STATE";
     /**
@@ -138,6 +151,8 @@ declare class SchemaError extends Error {
  * Base class for "not found" errors
  */
 declare class NotFoundError extends SchemaError {
+    /** Literal discriminator for `Effect.catchTag`; a widened `string` breaks narrowing. */
+    readonly _tag = "NotFoundError";
     readonly resourceType: string;
     readonly resourceId: string;
     constructor(resourceType: string, resourceId: string, code?: SchemaErrorCode, message?: string);
@@ -180,6 +195,8 @@ interface ValidationErrorDetail {
  * Validation error thrown when data fails schema validation
  */
 declare class ValidationError extends SchemaError {
+    /** Literal discriminator for `Effect.catchTag`; a widened `string` breaks narrowing. */
+    readonly _tag = "ValidationError";
     readonly errors: ValidationErrorDetail[];
     constructor(message: string, errors: ValidationErrorDetail[]);
     /**
@@ -327,7 +344,11 @@ declare function isValidationError(error: unknown): error is ValidationError;
  */
 declare function isProtectedResourceError(error: unknown): error is ProtectedResourceError;
 /**
- * Error thrown when a user lacks permission to perform an action
+ * Error thrown when a user lacks permission to perform an action.
+ *
+ * That, and nothing else (#2681) — its message is redacted, so it must not
+ * carry a refusal a permission grant would not lift: use `WORKSPACE_INVARIANT`,
+ * `STATE_GATE`, `ACTOR_CONTEXT_REQUIRED` or `SYSTEM_ENTITY_IMMUTABLE` instead.
  */
 declare class ForbiddenError extends SchemaError {
     readonly objectName: string;

package/dist/exceptions.d.ts

@@ -1,5 +1,5 @@
-import { S as SchemaOperation } from './migrations-B1kkIhIX.js';
-import './attributes-D8eHv5Kf.js';
+import { S as SchemaOperation } from './migrations-DaFneOfx.js';
+import './attributes-CNYwg_Nr.js';
 import '@stndrds/constants';
 import './utils.js';
 
@@ -23,6 +23,19 @@ declare const SchemaErrorCode: {
     readonly PROTECTED_ROLE: "SCHEMA_PROTECTED_ROLE";
     readonly FORBIDDEN: "SCHEMA_FORBIDDEN";
     readonly ACCESS_DENIED: "SCHEMA_ACCESS_DENIED";
+    /**
+     * A workspace RULE refuses the write — the last owner cannot be removed.
+     *
+     * Not `INVARIANT_VIOLATION`, despite the name: that one is an internal
+     * "should never happen" assertion, a bug signal nobody outside the codebase
+     * can act on. This is the opposite — a rule the caller can act on, reached
+     * by a request that was entirely well-formed, whose message tells them how.
+     */
+    readonly WORKSPACE_INVARIANT: "SCHEMA_WORKSPACE_INVARIANT";
+    /** The resource's own state refuses the operation — a disarmed reflex run. */
+    readonly STATE_GATE: "SCHEMA_STATE_GATE";
+    /** The operation needs an actor and the request carried none. */
+    readonly ACTOR_CONTEXT_REQUIRED: "SCHEMA_ACTOR_CONTEXT_REQUIRED";
     readonly CONNECTOR_AUTH_FAILED: "SCHEMA_CONNECTOR_AUTH_FAILED";
     readonly CONNECTOR_INVALID_STATE: "SCHEMA_CONNECTOR_INVALID_STATE";
     /**
@@ -138,6 +151,8 @@ declare class SchemaError extends Error {
  * Base class for "not found" errors
  */
 declare class NotFoundError extends SchemaError {
+    /** Literal discriminator for `Effect.catchTag`; a widened `string` breaks narrowing. */
+    readonly _tag = "NotFoundError";
     readonly resourceType: string;
     readonly resourceId: string;
     constructor(resourceType: string, resourceId: string, code?: SchemaErrorCode, message?: string);
@@ -180,6 +195,8 @@ interface ValidationErrorDetail {
  * Validation error thrown when data fails schema validation
  */
 declare class ValidationError extends SchemaError {
+    /** Literal discriminator for `Effect.catchTag`; a widened `string` breaks narrowing. */
+    readonly _tag = "ValidationError";
     readonly errors: ValidationErrorDetail[];
     constructor(message: string, errors: ValidationErrorDetail[]);
     /**
@@ -327,7 +344,11 @@ declare function isValidationError(error: unknown): error is ValidationError;
  */
 declare function isProtectedResourceError(error: unknown): error is ProtectedResourceError;
 /**
- * Error thrown when a user lacks permission to perform an action
+ * Error thrown when a user lacks permission to perform an action.
+ *
+ * That, and nothing else (#2681) — its message is redacted, so it must not
+ * carry a refusal a permission grant would not lift: use `WORKSPACE_INVARIANT`,
+ * `STATE_GATE`, `ACTOR_CONTEXT_REQUIRED` or `SYSTEM_ENTITY_IMMUTABLE` instead.
  */
 declare class ForbiddenError extends SchemaError {
     readonly objectName: string;