@resistdesign/voltra 3.0.0-alpha.44 → 3.0.0-alpha.46

package/README.md

@@ -242,6 +242,7 @@ const coords = layout.computeNativeCoords({
 
 Voltra routing uses the same `Route` API across app/web/native.
 Use the platform barrel for root `Route` so runtime mechanics are auto-wired.
+The routing model is path/history based on every platform.
 
 Reference example: `examples/routing/app-routing.ts`
 
@@ -271,10 +272,22 @@ import { Route } from "@resistdesign/voltra/native";
 </Route>;
 ```
 
+On native, Voltra provides the missing browser-like pieces:
+
+- history-style path state for environments without the browser History API
+- deep-link URL ingress so app opens behave like web navigations
+- hardware back wiring into that same history model
+- the `native` barrel auto-selects browser behavior on React Native web targets
+  and native-history behavior on mobile targets
+
 How it works:
 
 - Root `<Route>` (no `path`) is provider mode.
 - Nested `<Route path="...">` entries are matcher mode.
+- Shared app routing matches normalized path strings on every platform.
+- Web already receives a browser pathname.
+- Native provides the browser-like history/path source that mobile lacks.
+- Native deep-link ingress is mapped into that same path/history model.
 - Strategy is auto-selected:
   - DOM + History API => browser history strategy.
   - Otherwise => in-memory native strategy.

package/api/ORM/ORMRouteMap.d.ts

@@ -17,6 +17,17 @@
 import { BaseTypeInfoORMServiceConfig, TypeInfoORMDACConfig } from "./TypeInfoORMService";
 import { AuthInfo, RouteAuthConfig, RouteMap } from "../Router/Types";
 import { TypeInfoORMAPI } from "../../common/TypeInfoORM";
+/**
+ * Optional configuration for Type Info ORM route-map behavior.
+ */
+export type TypeInfoORMRouteMapConfig = {
+    /**
+     * Whether update handlers should forward field operators from request args.
+     *
+     * Defaults to `true`.
+     */
+    allowUpdateFieldOperators?: boolean;
+};
 /**
  * A collection of errors that can occur when creating or using a Type Info ORM Route Map.
  * */
@@ -52,4 +63,8 @@ getAccessingRoleId?: (authInfo: AuthInfo) => string,
 /**
  * Optional route-level auth configuration.
  */
-authConfig?: RouteAuthConfig) => RouteMap;
+authConfig?: RouteAuthConfig, 
+/**
+ * Optional route-map behavior config.
+ */
+routeMapConfig?: TypeInfoORMRouteMapConfig) => RouteMap;

package/api/ORM/TypeInfoORMService.d.ts

@@ -8,7 +8,7 @@
 import { LiteralValue, TypeInfo, TypeInfoDataItem, TypeInfoField, TypeInfoMap, TypeOperation } from "../../common/TypeParsing/TypeInfo";
 import { CustomTypeInfoFieldValidatorMap } from "../../common/TypeParsing/Validation";
 import { ComparisonOperators, FieldCriterion, ListItemsConfig, ListItemsResults, ListRelationshipsConfig, SearchCriteria } from "../../common/SearchTypes";
-import { DeleteRelationshipResults, RelationshipOperation, TypeInfoORMAPI, TypeInfoORMContext } from "../../common/TypeInfoORM";
+import { DeleteRelationshipResults, RelationshipOperation, TypeInfoORMAPI, TypeInfoORMContext, TypeInfoORMUpdateConfig } from "../../common/TypeInfoORM";
 import { DataItemDBDriver, IndexingRelationshipDriver, ItemRelationshipDBDriver } from "./drivers";
 import { BaseItemRelationshipInfo, ItemRelationshipInfo, ItemRelationshipInfoKeys, ItemRelationshipInfoType, ItemRelationshipOriginatingItemInfo } from "../../common/ItemRelationshipInfoTypes";
 import { DACAccessResult, DACDataItemResourceAccessResultMap, DACRole } from "../DataAccessControl";
@@ -738,6 +738,10 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
      * Whether the item is a partial update.
      */
     itemIsPartial?: boolean) => void;
+    /**
+     * Validate update operator config against the target TypeInfo fields.
+     */
+    protected validateUpdateConfig: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig) => void;
     /**
      * @returns Cleaned item with selected fields and DAC constraints applied.
      */
@@ -853,9 +857,10 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
      * The `item` **must always** contain its **primary field value**.
      * @param typeName Type name to update.
      * @param item Item payload to update.
+     * @param updateConfig Optional per-field operator config.
      * @returns True when the update succeeded.
      * */
-    update: (typeName: string, item: TypeInfoDataItem, context?: TypeInfoORMContext) => Promise<boolean>;
+    update: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig, context?: TypeInfoORMContext) => Promise<boolean>;
     /**
      * Delete an existing item of the given type.
      * @param typeName Type name to delete.

package/api/ORM/drivers/DynamoDBDataItemDBDriver.d.ts

@@ -7,6 +7,7 @@
 import { DataItemDBDriver, DataItemDBDriverConfig, SupportedDataItemDBDriverEntry } from "./common/Types";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { TypeInfoDataItem } from "../../../common/TypeParsing/TypeInfo";
+import { TypeInfoORMUpdateConfig } from "../../../common/TypeInfoORM";
 import { ListItemsConfig, ListItemsResults } from "../../../common/SearchTypes";
 /**
  * A {@link DataItemDBDriver} that uses DynamoDB as its database.
@@ -59,7 +60,7 @@ export declare class DynamoDBDataItemDBDriver<ItemType extends TypeInfoDataItem,
     /**
      * Partial update payload for the item.
      */
-    updatedItem: Partial<ItemType>) => Promise<boolean>;
+    updatedItem: Partial<ItemType>, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item from the database.
      * @returns True when an item was deleted.

package/api/ORM/drivers/InMemoryDataItemDBDriver.d.ts

@@ -1,6 +1,7 @@
 import { DataItemDBDriver, DataItemDBDriverConfig, SupportedDataItemDBDriverEntry } from "./common/Types";
 import type { TypeInfoDataItem } from "../../../common/TypeParsing/TypeInfo";
 import type { ListItemsConfig, ListItemsResults } from "../../../common/SearchTypes";
+import { TypeInfoORMUpdateConfig } from "../../../common/TypeInfoORM";
 /**
  * In-memory data item driver for testing and local usage.
  */
@@ -34,7 +35,7 @@ export declare class InMemoryDataItemDBDriver<ItemType extends TypeInfoDataItem,
      * @param updatedItem Partial update payload for the item.
      * @returns True when the item was updated.
      */
-    updateItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName], updatedItem: Partial<ItemType>) => Promise<boolean>;
+    updateItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName], updatedItem: Partial<ItemType>, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item from memory.
      * @param uniqueIdentifier Unique identifier value for the item.

package/api/ORM/drivers/common/Types.d.ts

@@ -1,6 +1,7 @@
 import { TypeInfoDataItem, TypeInfoPack } from "../../../../common/TypeParsing/TypeInfo";
 import { ItemRelationshipInfo, ItemRelationshipInfoIdentifyingKeys } from "../../../../common/ItemRelationshipInfoTypes";
 import { ListItemsConfig, ListItemsResults } from "../../../../common/SearchTypes";
+import type { TypeInfoORMUpdateConfig } from "../../../../common/TypeInfoORM/Types";
 /**
  * The errors that can be thrown by a {@link DataItemDBDriver}.
  * */
@@ -24,7 +25,11 @@ export declare enum DATA_ITEM_DB_DRIVER_ERRORS {
     /**
      * Search operator is not supported by the driver.
      */
-    SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED = "SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED"
+    SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED = "SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED",
+    /**
+     * Update operator is not supported by the driver.
+     */
+    UPDATE_OPERATOR_NOT_SUPPORTED = "UPDATE_OPERATOR_NOT_SUPPORTED"
 }
 /**
  * The generic type for a database driver configuration.
@@ -70,7 +75,7 @@ export type DataItemDBDriver<ItemType extends TypeInfoDataItem, UniquelyIdentify
      * @param updatedItem Partial update payload for the item.
      * @returns True when the item was updated.
      */
-    updateItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName], updatedItem: Partial<ItemType>) => Promise<boolean>;
+    updateItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName], updatedItem: Partial<ItemType>, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item from the data store.
      * @param uniqueIdentifier Unique identifier value for the item.

package/api/index.js

@@ -1,4 +1,4 @@
-import { ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, ComparisonOperators } from '../chunk-7AMEFPPP.js';
+import { TypeInfoORMUpdateOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, ComparisonOperators } from '../chunk-RUNXRISF.js';
 import { getNoErrorDescriptor, getErrorDescriptor, ERROR_MESSAGE_CONSTANTS, validateTypeOperationAllowed, getValidityValue, validateTypeInfoValue, validateTypeInfoFieldValue } from '../chunk-YCTVEW2I.js';
 import { mergeStringPaths, getPathString, getPathArray } from '../chunk-WNFRDIBW.js';
 import '../chunk-I2KLQ2HA.js';
@@ -4540,6 +4540,7 @@ var DATA_ITEM_DB_DRIVER_ERRORS = /* @__PURE__ */ ((DATA_ITEM_DB_DRIVER_ERRORS2)
   DATA_ITEM_DB_DRIVER_ERRORS2["ITEM_NOT_FOUND"] = "ITEM_NOT_FOUND";
   DATA_ITEM_DB_DRIVER_ERRORS2["MISSING_UNIQUE_IDENTIFIER"] = "MISSING_UNIQUE_IDENTIFIER";
   DATA_ITEM_DB_DRIVER_ERRORS2["SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED"] = "SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED";
+  DATA_ITEM_DB_DRIVER_ERRORS2["UPDATE_OPERATOR_NOT_SUPPORTED"] = "UPDATE_OPERATOR_NOT_SUPPORTED";
   return DATA_ITEM_DB_DRIVER_ERRORS2;
 })(DATA_ITEM_DB_DRIVER_ERRORS || {});
 
@@ -5778,8 +5779,9 @@ var createFilterExpression = (fieldCriteria, logicalOperator) => {
   }
   return output;
 };
-var buildUpdateExpression = (updatedItem, uniquelyIdentifyingFieldName) => {
-  const updateExpressionParts = [];
+var buildUpdateExpression = (updatedItem, uniquelyIdentifyingFieldName, updateConfig) => {
+  const setExpressionParts = [];
+  const addExpressionParts = [];
   const attributeNames = {};
   const attributeValues = {};
   for (const f in updatedItem) {
@@ -5787,13 +5789,35 @@ var buildUpdateExpression = (updatedItem, uniquelyIdentifyingFieldName) => {
     if (f !== uniquelyIdentifyingFieldName && typeof value !== "undefined") {
       const placeholderName = `#${f}`;
       const placeholderValue = `:${f}`;
-      updateExpressionParts.push(`${placeholderName} = ${placeholderValue}`);
+      const operator = updateConfig?.fieldOperators?.[f];
       attributeNames[placeholderName] = f;
       attributeValues[placeholderValue] = marshall(value);
+      if (operator === TypeInfoORMUpdateOperators.NUMBER.INCREMENT) {
+        addExpressionParts.push(`${placeholderName} ${placeholderValue}`);
+        continue;
+      }
+      if (operator === TypeInfoORMUpdateOperators.NUMBER.DECREMENT) {
+        const decrementPlaceholderValue = `:${f}_decrement`;
+        addExpressionParts.push(
+          `${placeholderName} ${decrementPlaceholderValue}`
+        );
+        attributeValues[decrementPlaceholderValue] = marshall(
+          -value
+        );
+        continue;
+      }
+      setExpressionParts.push(`${placeholderName} = ${placeholderValue}`);
     }
   }
+  const expressionParts = [];
+  if (setExpressionParts.length > 0) {
+    expressionParts.push(`SET ${setExpressionParts.join(", ")}`);
+  }
+  if (addExpressionParts.length > 0) {
+    expressionParts.push(`ADD ${addExpressionParts.join(", ")}`);
+  }
   return {
-    UpdateExpression: `SET ${updateExpressionParts.join(", ")}`,
+    UpdateExpression: expressionParts.join(" "),
     ExpressionAttributeNames: attributeNames,
     ExpressionAttributeValues: attributeValues
   };
@@ -5872,7 +5896,7 @@ var DynamoDBDataItemDBDriver = class {
    * Update an item in the database.
    * @returns True when an item was updated.
    */
-  updateItem = async (uniqueIdentifier, updatedItem) => {
+  updateItem = async (uniqueIdentifier, updatedItem, updateConfig) => {
     const { tableName, uniquelyIdentifyingFieldName } = this.config;
     const {
       [uniquelyIdentifyingFieldName]: _unusedUniqueIdentifier,
@@ -5887,7 +5911,8 @@ var DynamoDBDataItemDBDriver = class {
         ReturnValues: "ALL_NEW",
         ...buildUpdateExpression(
           cleanUpdatedItem,
-          uniquelyIdentifyingFieldName
+          uniquelyIdentifyingFieldName,
+          updateConfig
         )
       });
       const { Attributes } = await this.dynamoDBClient.send(command);
@@ -6092,7 +6117,7 @@ var InMemoryDataItemDBDriver = class {
    * @param updatedItem Partial update payload for the item.
    * @returns True when the item was updated.
    */
-  updateItem = async (uniqueIdentifier, updatedItem) => {
+  updateItem = async (uniqueIdentifier, updatedItem, updateConfig) => {
     const { uniquelyIdentifyingFieldName } = this.config;
     if (typeof uniqueIdentifier === "undefined") {
       throw {
@@ -6110,6 +6135,17 @@ var InMemoryDataItemDBDriver = class {
     };
     for (const [key, value] of Object.entries(cleanUpdatedItem)) {
       if (typeof value !== "undefined") {
+        const operator = updateConfig?.fieldOperators?.[key];
+        if (operator === TypeInfoORMUpdateOperators.NUMBER.INCREMENT) {
+          const currentValue = nextItem[key];
+          nextItem[key] = (typeof currentValue === "number" ? currentValue : 0) + value;
+          continue;
+        }
+        if (operator === TypeInfoORMUpdateOperators.NUMBER.DECREMENT) {
+          const currentValue = nextItem[key];
+          nextItem[key] = (typeof currentValue === "number" ? currentValue : 0) - value;
+          continue;
+        }
         nextItem[key] = value;
       }
     }
@@ -8209,6 +8245,40 @@ var TypeInfoORMService = class {
       throw validationResults;
     }
   };
+  /**
+   * Validate update operator config against the target TypeInfo fields.
+   */
+  validateUpdateConfig = (typeName, item, updateConfig) => {
+    const fieldOperators = updateConfig?.fieldOperators;
+    if (!fieldOperators) {
+      return;
+    }
+    const { fields = {}, primaryField } = this.getTypeInfo(typeName);
+    for (const [fieldName, operator] of Object.entries(fieldOperators)) {
+      const field = fields[fieldName];
+      const itemValue = item[fieldName];
+      const isNumberOperator = Object.values(
+        TypeInfoORMUpdateOperators.NUMBER
+      ).includes(
+        operator
+      );
+      if (!field || fieldName === primaryField || !isNumberOperator || field.array || field.type !== "number" || typeof itemValue !== "number") {
+        const validationResults = {
+          typeName,
+          valid: false,
+          error: getErrorDescriptor(
+            "INVALID_UPDATE_OPERATOR" /* INVALID_UPDATE_OPERATOR */
+          ),
+          errorMap: {
+            [fieldName]: [
+              getErrorDescriptor("INVALID_UPDATE_OPERATOR" /* INVALID_UPDATE_OPERATOR */)
+            ]
+          }
+        };
+        throw validationResults;
+      }
+    }
+  };
   /**
    * @returns Cleaned item with selected fields and DAC constraints applied.
    */
@@ -8682,10 +8752,12 @@ var TypeInfoORMService = class {
    * The `item` **must always** contain its **primary field value**.
    * @param typeName Type name to update.
    * @param item Item payload to update.
+   * @param updateConfig Optional per-field operator config.
    * @returns True when the update succeeded.
    * */
-  update = async (typeName, item, context) => {
+  update = async (typeName, item, updateConfig, context) => {
     this.validate(typeName, item, "UPDATE" /* UPDATE */, true);
+    this.validateUpdateConfig(typeName, item, updateConfig);
     const { primaryField } = this.getTypeInfo(typeName);
     const primaryFieldValue = typeof item === "object" && item !== null ? item[primaryField] : void 0;
     if (typeof primaryFieldValue === "undefined") {
@@ -8761,7 +8833,11 @@ var TypeInfoORMService = class {
             throw error;
           }
         }
-        const result = await driver.updateItem(primaryFieldValue, cleanItem);
+        const result = await driver.updateItem(
+          primaryFieldValue,
+          cleanItem,
+          updateConfig
+        );
         const updatedItem = await driver.readItem(primaryFieldValue);
         if (existingItem) {
           await this.replaceItemIndexes(typeName, existingItem, updatedItem);
@@ -9411,7 +9487,7 @@ var TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP = {
   delete: "delete",
   list: "list"
 };
-var getTypeInfoORMRouteMap = (config, dacConfig, getAccessingRoleId, authConfig) => {
+var getTypeInfoORMRouteMap = (config, dacConfig, getAccessingRoleId, authConfig, routeMapConfig) => {
   if (dacConfig && !getAccessingRoleId) {
     throw {
       message: "MISSING_ACCESSING_ROLE_GETTER" /* MISSING_ACCESSING_ROLE_GETTER */
@@ -9430,6 +9506,7 @@ var getTypeInfoORMRouteMap = (config, dacConfig, getAccessingRoleId, authConfig)
   const defaultAuthConfig = authConfig ?? {
     anyAuthorized: true
   };
+  const allowUpdateFieldOperators = routeMapConfig?.allowUpdateFieldOperators ?? true;
   const resolveContext = (eventData) => getContextFromEventData(eventData, dacConfig, getAccessingRoleId);
   const createRoute = (path, handlerFactory) => ({
     path,
@@ -9450,10 +9527,18 @@ var getTypeInfoORMRouteMap = (config, dacConfig, getAccessingRoleId, authConfig)
   };
   const updateHandlerFactory = (eventData) => {
     if (!dacConfig) {
-      return orm.update;
+      if (allowUpdateFieldOperators) {
+        return orm.update;
+      }
+      return ((typeName, item) => orm.update(typeName, item, void 0));
     }
     const context = resolveContext(eventData);
-    return ((typeName, item) => orm.update(typeName, item, context));
+    return ((typeName, item, updateConfig) => orm.update(
+      typeName,
+      item,
+      allowUpdateFieldOperators ? updateConfig : void 0,
+      context
+    ));
   };
   const deleteHandlerFactory = (eventData) => {
     if (!dacConfig) {

package/app/index.js

@@ -1,7 +1,7 @@
 export { createEasyLayout, getEasyLayoutTemplateDetails, getPascalCaseAreaName } from '../chunk-CMH6L5QQ.js';
 export { computeTrackPixels } from '../chunk-TJFTWPXQ.js';
 export { AutoForm, AutoFormView, Route, RouteContext, RouteContextConsumer, RouteContextProvider, RouteProvider, buildHistoryPath, buildQueryString, buildRoutePath, canUseBrowserHistory, computeAreaBounds, createAutoField, createBrowserRouteAdapter, createFormRenderer, createHistoryBackHandler, createManualRouteAdapter, createMemoryHistory, createNativeRouteAdapter, createRouteAdapterFromHistory, createUniversalAdapter, defaultTranslateValidationErrorCode, getFieldKind, parseHistoryPath, parseTemplate, resolveSuite, useFormEngine, useRouteContext, validateAreas, wrapRouteAdapterWithPathResolver } from '../chunk-44BMFTKD.js';
-import '../chunk-7AMEFPPP.js';
+import '../chunk-RUNXRISF.js';
 import '../chunk-YCTVEW2I.js';
 import { mergeStringPaths, PATH_DELIMITER } from '../chunk-WNFRDIBW.js';
 import '../chunk-I2KLQ2HA.js';
@@ -473,12 +473,14 @@ var TypeInfoORMClient = class {
    *
    * @param typeName - TypeInfo type name.
    * @param item - Updated item payload.
+   * @param updateConfig - Optional per-field operator config.
    * @returns Whether the update succeeded.
    */
-  update = async (typeName, item) => {
+  update = async (typeName, item, updateConfig) => {
     return await this.makeRequest("update" /* UPDATE */, [
       typeName,
-      item
+      item,
+      updateConfig
     ]);
   };
   /**

package/app/utils/TypeInfoORMClient.d.ts

@@ -4,7 +4,7 @@
  * Client wrapper around the TypeInfoORM API RouteMap. Uses ServiceConfig to
  * route requests to the server-side TypeInfoORM routes.
  */
-import { DeleteRelationshipResults, TypeInfoORMClientAPI, TypeInfoORMAPIRoutePaths } from "../../common/TypeInfoORM";
+import { DeleteRelationshipResults, TypeInfoORMClientAPI, TypeInfoORMAPIRoutePaths, TypeInfoORMUpdateConfig } from "../../common/TypeInfoORM";
 import { ServiceConfig } from "./Service";
 import { TypeInfoDataItem } from "../../common/TypeParsing/TypeInfo";
 import { ListItemsConfig, ListItemsResults, ListRelationshipsConfig } from "../../common/SearchTypes";
@@ -51,9 +51,10 @@ export declare class TypeInfoORMClient implements TypeInfoORMClientAPI {
      *
      * @param typeName - TypeInfo type name.
      * @param item - Updated item payload.
+     * @param updateConfig - Optional per-field operator config.
      * @returns Whether the update succeeded.
      */
-    update: (typeName: string, item: TypeInfoDataItem) => Promise<boolean>;
+    update: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item by its primary field value.
      *

package/{chunk-7AMEFPPP.js → chunk-RUNXRISF.js}

@@ -54,6 +54,7 @@ var TypeInfoORMServiceError = /* @__PURE__ */ ((TypeInfoORMServiceError2) => {
   TypeInfoORMServiceError2["TYPE_INFO_MISSING_PRIMARY_FIELD"] = "TYPE_INFO_MISSING_PRIMARY_FIELD";
   TypeInfoORMServiceError2["INVALID_RELATIONSHIP"] = "INVALID_RELATIONSHIP";
   TypeInfoORMServiceError2["INVALID_OPERATION"] = "INVALID_OPERATION";
+  TypeInfoORMServiceError2["INVALID_UPDATE_OPERATOR"] = "INVALID_UPDATE_OPERATOR";
   TypeInfoORMServiceError2["MISSING_ACCESSING_ROLE"] = "MISSING_ACCESSING_ROLE";
   TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_CRITERIA"] = "INDEXING_UNSUPPORTED_CRITERIA";
   TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_COMBINATION"] = "INDEXING_UNSUPPORTED_COMBINATION";
@@ -74,5 +75,11 @@ var TypeInfoORMAPIRoutePaths = /* @__PURE__ */ ((TypeInfoORMAPIRoutePaths2) => {
   TypeInfoORMAPIRoutePaths2["LIST_RELATED_ITEMS"] = "list-related-items";
   return TypeInfoORMAPIRoutePaths2;
 })(TypeInfoORMAPIRoutePaths || {});
+var TypeInfoORMUpdateOperators = {
+  NUMBER: {
+    INCREMENT: "INCREMENT",
+    DECREMENT: "DECREMENT"
+  }
+};
 
-export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError };
+export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError, TypeInfoORMUpdateOperators };

package/common/TypeInfoORM/Types.d.ts

@@ -91,6 +91,10 @@ export declare enum TypeInfoORMServiceError {
      * Operation is not supported.
      * */
     INVALID_OPERATION = "INVALID_OPERATION",
+    /**
+     * Update operator config is invalid.
+     * */
+    INVALID_UPDATE_OPERATOR = "INVALID_UPDATE_OPERATOR",
     /**
      * Accessing role is missing when DAC is required.
      * */
@@ -181,6 +185,32 @@ export type TypeInfoORMContext = {
      */
     accessingRoleId: string;
 };
+/**
+ * Supported numeric field update operators.
+ */
+export declare const TypeInfoORMUpdateOperators: {
+    readonly NUMBER: {
+        readonly INCREMENT: "INCREMENT";
+        readonly DECREMENT: "DECREMENT";
+    };
+};
+/**
+ * Supported numeric field update operator values.
+ */
+export type TypeInfoORMNumberFieldUpdateOperator = (typeof TypeInfoORMUpdateOperators.NUMBER)[keyof typeof TypeInfoORMUpdateOperators.NUMBER];
+/**
+ * Supported field update operator values.
+ */
+export type TypeInfoORMFieldUpdateOperator = TypeInfoORMNumberFieldUpdateOperator;
+/**
+ * Optional config for TypeInfo ORM update calls.
+ */
+export type TypeInfoORMUpdateConfig = {
+    /**
+     * Optional per-field operator map applied during update.
+     */
+    fieldOperators?: Record<string, TypeInfoORMFieldUpdateOperator>;
+};
 /**
  * Server-side TypeInfoORM API contract.
  *
@@ -239,9 +269,10 @@ export type TypeInfoORMAPI = {
      *
      * @param typeName - Type name to update.
      * @param item - Updated item payload.
+     * @param updateConfig - Optional per-field operator config.
      * @returns Whether the update succeeded.
      */
-    update: (typeName: string, item: TypeInfoDataItem, context?: TypeInfoORMContext) => Promise<boolean>;
+    update: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig, context?: TypeInfoORMContext) => Promise<boolean>;
     /**
      * Delete an item by primary field value.
      *
@@ -319,9 +350,10 @@ export type TypeInfoORMClientAPI = {
      *
      * @param typeName - Type name to update.
      * @param item - Updated item payload.
+     * @param updateConfig - Optional per-field operator config.
      * @returns Whether the update succeeded.
      */
-    update: (typeName: string, item: TypeInfoDataItem) => Promise<boolean>;
+    update: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item by primary field value.
      *

package/common/index.js

@@ -1,4 +1,4 @@
-export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError } from '../chunk-7AMEFPPP.js';
+export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError, TypeInfoORMUpdateOperators } from '../chunk-RUNXRISF.js';
 export { DENIED_TYPE_OPERATIONS, ERROR_MESSAGE_CONSTANTS, INVALID_CUSTOM_TYPE, PRIMITIVE_ERROR_MESSAGE_CONSTANTS, RelationshipValidationType, TYPE_KEYWORD_ERROR_MESSAGE_CONSTANTS, TYPE_KEYWORD_VALIDATORS, TypeOperation, getArrayItemErrorMap, getErrorDescriptor, getErrorDescriptors, getNoErrorDescriptor, getValidityValue, hasValue, isArrayErrorDescriptorCollection, validateArrayOfTypeInfoFieldValues, validateCustomType, validateKeywordType, validateTypeInfoDataItem, validateTypeInfoFieldOperationAllowed, validateTypeInfoFieldValue, validateTypeInfoValue, validateTypeOperationAllowed, validateValueMatchesPattern } from '../chunk-YCTVEW2I.js';
 import '../chunk-WNFRDIBW.js';
 import '../chunk-I2KLQ2HA.js';

package/native/index.js

@@ -1,9 +1,9 @@
 import { computeTrackPixels } from '../chunk-TJFTWPXQ.js';
-import { createFormRenderer, createHistoryBackHandler, buildHistoryPath, AutoFormView, AutoForm, parseTemplate, validateAreas, computeAreaBounds, parseHistoryPath, createMemoryHistory, Route, buildRoutePath } from '../chunk-44BMFTKD.js';
+import { createFormRenderer, createHistoryBackHandler, buildHistoryPath, AutoFormView, AutoForm, parseTemplate, validateAreas, computeAreaBounds, parseHistoryPath, createMemoryHistory, createBrowserRouteAdapter, Route, createRouteAdapterFromHistory } from '../chunk-44BMFTKD.js';
 import { ERROR_MESSAGE_CONSTANTS } from '../chunk-YCTVEW2I.js';
-import { resolveRouteAdapterPath, getPathArray } from '../chunk-WNFRDIBW.js';
+import '../chunk-WNFRDIBW.js';
 import '../chunk-I2KLQ2HA.js';
-import { createElement, useMemo } from 'react';
+import { createElement, useMemo, useRef } from 'react';
 import { Text, View, Platform, Switch, TextInput, Pressable, BackHandler } from 'react-native';
 import { jsx } from 'react/jsx-runtime';
 
@@ -580,10 +580,13 @@ var createNativeHistory = (options = {}) => {
     adapter,
     initialPath = "/",
     onIncomingURL = "replace",
-    mapURLToPath = mapNativeURLToPath
+    mapURLToPath = mapNativeURLToPath,
+    backHandler
   } = options;
   const history = createMemoryHistory(initialPath);
+  const historyBackHandler = createHistoryBackHandler(history);
   let unsubscribe;
+  let stopBackHandler;
   let started = false;
   const applyIncomingURL = (url) => {
     if (!url) {
@@ -620,6 +623,20 @@ var createNativeHistory = (options = {}) => {
         return;
       }
       started = true;
+      if (backHandler && !stopBackHandler) {
+        const listener = () => historyBackHandler.handle();
+        const subscription = backHandler.addEventListener(
+          "hardwareBackPress",
+          listener
+        );
+        stopBackHandler = () => {
+          if (typeof subscription?.remove === "function") {
+            subscription.remove();
+            return;
+          }
+          backHandler.removeEventListener?.("hardwareBackPress", listener);
+        };
+      }
       if (!adapter) {
         return;
       }
@@ -651,23 +668,13 @@ var createNativeHistory = (options = {}) => {
       }
       unsubscribe?.();
       unsubscribe = void 0;
+      stopBackHandler?.();
+      stopBackHandler = void 0;
       started = false;
     }
   };
 };
 var createNativeBackHandler = (history) => createHistoryBackHandler(history);
-var createNavigationStateRouteAdapter = (options) => {
-  const getPath = () => options.toPath(options.getState());
-  const resolvePath = (path) => resolveRouteAdapterPath(getPath(), path);
-  return {
-    getPath,
-    subscribe: (listener) => options.subscribe(() => {
-      listener(getPath());
-    }),
-    push: options.navigate ? (path) => options.navigate?.(resolvePath(path)) : void 0,
-    replace: options.replace ? (path) => options.replace?.(resolvePath(path)) : void 0
-  };
-};
 var createNativeHardwareBackHandler = (adapter) => {
   return () => {
     if (adapter.canGoBack?.()) {
@@ -696,53 +703,63 @@ var createNativeRouteBackIntegration = (backHandler) => {
     setup: (adapter) => registerNativeHardwareBackHandler(adapter, backHandler)
   };
 };
+var createNativeHistoryRouteAdapter = (initialPath, ingress, backHandler) => {
+  const history = createNativeHistory({
+    initialPath,
+    backHandler,
+    ...ingress ? {
+      adapter: {
+        getInitialURL: async () => await ingress.getInitialURL?.() ?? null,
+        subscribe: (listener) => ingress.subscribe?.(listener) ?? (() => {
+        })
+      },
+      onIncomingURL: ingress.onIncomingURL,
+      mapURLToPath: ingress.mapURLToPath
+    } : {}
+  });
+  const adapter = createRouteAdapterFromHistory(history);
+  let subscribers = 0;
+  return {
+    ...adapter,
+    subscribe: (listener) => {
+      subscribers += 1;
+      if (subscribers === 1) {
+        void history.start();
+      }
+      const unlisten = adapter.subscribe(listener);
+      return () => {
+        unlisten();
+        subscribers = Math.max(0, subscribers - 1);
+        if (subscribers === 0) {
+          history.stop();
+        }
+      };
+    }
+  };
+};
 var Route2 = (props) => {
   const hasMatcherProps = typeof props.path !== "undefined" || typeof props.exact !== "undefined" || typeof props.onParamsChange !== "undefined";
   const nativeRuntime = {
     platformOS: String(Platform?.OS ?? ""),
     backHandler: BackHandler
   };
-  const runtimeIntegration = (() => {
-    if (hasMatcherProps || nativeRuntime.platformOS === "web") {
-      return void 0;
-    }
-    const backHandler = nativeRuntime.backHandler;
-    if (!backHandler) {
-      return void 0;
-    }
-    return createNativeRouteBackIntegration(backHandler);
-  })();
-  return /* @__PURE__ */ jsx(
+  const shouldUseAutoAdapter = !hasMatcherProps && typeof props.adapter === "undefined";
+  const routeProps = props;
+  const adapterRef = useRef(null);
+  if (shouldUseAutoAdapter && !adapterRef.current) {
+    adapterRef.current = nativeRuntime.platformOS === "web" ? createBrowserRouteAdapter() : createNativeHistoryRouteAdapter(
+      props.initialPath,
+      props.ingress,
+      nativeRuntime.backHandler
+    );
+  }
+  return shouldUseAutoAdapter ? /* @__PURE__ */ jsx(
     Route,
     {
-      ...props,
-      runtimeIntegration
+      ...routeProps,
+      adapter: adapterRef.current ?? void 0
     }
-  );
-};
-var expandPattern = (pattern, params = {}) => {
-  const segments = getPathArray(pattern, "/", true, true, false, false);
-  return segments.map((segment) => {
-    if (segment.startsWith(":")) {
-      const key = segment.slice(1);
-      if (!(key in params)) {
-        throw new Error(`Missing param "${key}" for route pattern "${pattern}".`);
-      }
-      return params[key];
-    }
-    return segment;
-  });
-};
-var buildPathFromRouteChain = (routeChain, config, query) => {
-  const segments = [];
-  routeChain.forEach((route) => {
-    const pattern = config[route.name];
-    if (!pattern) {
-      throw new Error(`Missing route pattern for "${route.name}".`);
-    }
-    segments.push(...expandPattern(pattern, route.params));
-  });
-  return buildRoutePath(segments, query);
+  ) : /* @__PURE__ */ jsx(Route, { ...routeProps });
 };
 
-export { ArrayContainer, ArrayItemWrapper, AutoField, AutoForm2 as AutoForm, AutoFormView2 as AutoFormView, Button, ErrorMessage, FieldWrapper, NativeEasyLayoutView, Route2 as Route, buildPathFromRouteChain, createNativeBackHandler, createNativeFormRenderer, createNativeHardwareBackHandler, createNativeHistory, createNativeRouteBackIntegration, createNavigationStateRouteAdapter, makeNativeEasyLayout, mapNativeURLToPath, nativeAutoField, nativeSuite, registerNativeHardwareBackHandler, useNativeEasyLayout };
+export { ArrayContainer, ArrayItemWrapper, AutoField, AutoForm2 as AutoForm, AutoFormView2 as AutoFormView, Button, ErrorMessage, FieldWrapper, NativeEasyLayoutView, Route2 as Route, createNativeBackHandler, createNativeFormRenderer, createNativeHardwareBackHandler, createNativeHistory, createNativeRouteBackIntegration, makeNativeEasyLayout, mapNativeURLToPath, nativeAutoField, nativeSuite, registerNativeHardwareBackHandler, useNativeEasyLayout };

package/native/utils/History.d.ts

@@ -1,13 +1,15 @@
 /**
  * @packageDocumentation
  *
- * Native history helpers that adapt deep links into the shared history state machine.
+ * Native history helpers that provide the mobile equivalent of browser
+ * location/history behavior for shared app Route matching.
  */
 import type { HistoryController } from "../../app/utils/History";
 /**
  * Adapter contract for React Native deep-link APIs.
  *
- * Intended for RN `Linking` wrappers.
+ * Intended for RN `Linking` wrappers so native URL opens behave like browser
+ * navigations entering the shared Voltra history model.
  */
 export type NativeLinkAdapter = {
     /**
@@ -23,8 +25,19 @@ export type NativeLinkAdapter = {
  * Mode for incoming URL handling.
  */
 export type NativeIncomingURLMode = "push" | "replace";
+/**
+ * BackHandler-like contract for native platform back actions.
+ */
+export type NativeBackHandlerLike = {
+    addEventListener: (eventName: "hardwareBackPress", listener: () => boolean) => {
+        remove?: () => void;
+    } | void;
+    removeEventListener?: (eventName: "hardwareBackPress", listener: () => boolean) => void;
+};
 /**
  * Native history controller with explicit lifecycle hooks.
+ *
+ * This is the native/mobile analogue to browser-backed history in web apps.
  */
 export type NativeHistoryController = HistoryController & {
     /**
@@ -62,16 +75,25 @@ export type CreateNativeHistoryOptions = {
      * Default: {@link mapNativeURLToPath}.
      */
     mapURLToPath?: (url: string) => string;
+    /**
+     * Optional native platform back handler wired into this history runtime.
+     */
+    backHandler?: NativeBackHandlerLike;
 };
 /**
  * Default native URL -> path mapping.
  *
- * Strips scheme and host, preserves path + query + hash.
+ * Strips scheme and host, preserves path + query + hash so incoming native URLs
+ * become the same route paths used on web.
  */
 export declare const mapNativeURLToPath: (url: string) => string;
 /**
  * Create a native history controller backed by in-memory history.
  *
+ * This is the primary native routing primitive when the environment does not
+ * provide browser history. It gives shared Route matching a stable path/history
+ * source and applies incoming deep links as navigations in that same model.
+ *
  * Lifecycle behavior:
  * - `start()` is idempotent.
  * - `stop()` is idempotent.

package/native/utils/Route.d.ts

@@ -1,54 +1,19 @@
 /**
  * @packageDocumentation
  *
- * Native routing helpers that adapt common navigation state to RouteAdapter.
- */
-import { type PropsWithChildren } from "react";
-import type { RouteAdapter, RouteProps, RouteQuery, RouteRuntimeIntegration } from "../../app/utils/Route";
-/**
- * Options to adapt a navigation state container into a RouteAdapter.
- */
-export type NavigationStateAdapterOptions<TState> = {
-    /** Return the current navigation state. */
-    getState: () => TState;
-    /** Subscribe to navigation state changes. */
-    subscribe: (listener: () => void) => () => void;
-    /** Convert navigation state into a path string. */
-    toPath: (state: TState) => string;
-    /** Optional navigation handler used for push-style transitions. */
-    navigate?: (path: string) => void;
-    /** Optional navigation handler used for replace-style transitions. */
-    replace?: (path: string) => void;
-};
-/**
- * Contract for React Native BackHandler-like integrations.
- */
-export type NativeBackHandlerLike = {
-    addEventListener: (eventName: "hardwareBackPress", listener: () => boolean) => {
-        remove?: () => void;
-    } | void;
-    removeEventListener?: (eventName: "hardwareBackPress", listener: () => boolean) => void;
-};
-/**
- * Route node in a navigation chain.
- */
-export type NavigationRouteNode = {
-    /** Route name as reported by the navigation library. */
-    name: string;
-    /** Optional route params used to populate path patterns. */
-    params?: Record<string, any>;
-};
-/**
- * Mapping of route names to path patterns (e.g. "books/:id").
- */
-export type NavigationRouteConfig = Record<string, string>;
-/**
- * Create a RouteAdapter from a navigation state container (e.g., react-navigation).
+ * Native routing helpers that keep shared app Route semantics intact on mobile.
  *
- * @param options - Adapter options for accessing and observing navigation state.
- * @returns RouteAdapter bound to the navigation state.
+ * The primary native model is still Voltra path/history routing. These helpers
+ * supply the runtime selection needed by the `native` barrel:
+ * - React Native mobile uses native history + deep-link + platform back
+ * - React Native web uses the browser adapter
+ *
+ * This separation keeps `app` free of native-platform code.
  */
-export declare const createNavigationStateRouteAdapter: <TState>(options: NavigationStateAdapterOptions<TState>) => RouteAdapter;
+import { type PropsWithChildren } from "react";
+import type { RouteProps, RouteRuntimeIntegration } from "../../app/utils/Route";
+import type { RouteAdapter } from "../../app/utils/Route";
+import { type NativeBackHandlerLike } from "./History";
 /**
  * Create a hardware-back listener from a route adapter.
  */
@@ -58,23 +23,19 @@ export declare const createNativeHardwareBackHandler: (adapter: RouteAdapter) =>
  */
 export declare const registerNativeHardwareBackHandler: (adapter: RouteAdapter, backHandler: NativeBackHandlerLike) => () => void;
 /**
- * Build a core Route runtime integration using a native BackHandler.
+ * Low-level helper to build a Route runtime integration from a BackHandler.
+ *
+ * Native Route no longer uses this for the default path because platform back
+ * ownership now lives with the native adapter/history layer. This remains
+ * available for manual integrations.
  */
 export declare const createNativeRouteBackIntegration: (backHandler: NativeBackHandlerLike) => RouteRuntimeIntegration;
 /**
  * Native Route wrapper for root/provider mode.
  *
  * Behavior:
- * - On mobile native runtimes, injects back-handler integration into app Route.
- * - On web runtimes, passes no integration so app Route uses browser behavior.
+ * - On React Native mobile runtimes, auto-injects a native-history-backed
+ *   adapter so native history owns platform back actions.
+ * - On React Native web runtimes, auto-injects the browser adapter.
  */
 export declare const Route: <ParamsType extends Record<string, any>>(props: PropsWithChildren<RouteProps<ParamsType>>) => import("react/jsx-runtime").JSX.Element;
-/**
- * Build a path from a navigation route chain and route config mapping.
- *
- * @param routeChain - Ordered list of routes from root to leaf.
- * @param config - Route name to path pattern mapping.
- * @param query - Optional query parameters appended to the path.
- * @returns Serialized path string.
- */
-export declare const buildPathFromRouteChain: (routeChain: NavigationRouteNode[], config: NavigationRouteConfig, query?: RouteQuery) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resistdesign/voltra",
-  "version": "3.0.0-alpha.44",
+  "version": "3.0.0-alpha.46",
   "description": "With our powers combined!",
   "homepage": "https://voltra.app",
   "repository": "git@github.com:resistdesign/voltra.git",