class State {
  constructor(context) {
    this.context = context;
    this.frozenState = null;
    this.initialized = false;
  }

  set(field, value) {
    // Dot-notation path support
    set(this.context.state, field, value);
  }

  del(field) {
    // Remove field and clean empty parents
    unset(this.context.state, field);
  }

  freezeState() {
    // Called after onInit - snapshot for reset
    if (!this.initialized) {
      this.frozenState = serializeToString(this.context.state);
      this.initialized = true;
    }
  }

  resetState() {
    // Restore to frozen initial state
    Object.keys(this.context.state).forEach((key) => delete this.context.state[key]);
    const frozen = deserializeFromString(this.frozenState);
    Object.keys(frozen).forEach((key) => this.set(key, frozen[key]));
  }

  swapItems(field, from, to) {
    // Swap array items (for reordering)
  }

  removeItem(field, index) {
    // Remove array item at index
  }
}

const ctx = {
  id,
  pageId: config.pageId,
  eventLog: [],
  jsMap,
  requests: {},
  state: {},              // Empty state object
  _internal: {
    lowdefy,
    rootBlock: config,
    parser: WebParser,
    State: new State(ctx),
    Actions: new Actions(ctx),
    Requests: new Requests(ctx),
    RootAreas: new Areas({...}),
    update: () => _internal.RootAreas.update()
  }
};

getContext()
    ↓
RootAreas.init()
    ↓
Block.reset(initState)
    ↓
Input blocks: State.set(blockId, initValue)
    ↓
Block.evaluate()
    ↓
onInit event
    ↓
State.freezeState()  // Snapshot for reset

function _state({ arrayIndices, location, params, state }) {
  return getFromObject({
    arrayIndices,
    location,
    object: state,
    operator: '_state',
    params,
  });
}

# Simple access
value:
  _state: user.name

# With default
value:
  _state:
    key: user.name
    default: "Anonymous"

function _input({ arrayIndices, input, location, params }) {
  return getFromObject({
    arrayIndices,
    location,
    object: input,
    operator: '_input',
    params,
  });
}

function _global({ arrayIndices, location, lowdefyGlobal, params }) {
  return getFromObject({
    arrayIndices,
    location,
    object: lowdefyGlobal,
    operator: '_global',
    params,
  });
}

function _url_query({ arrayIndices, globals, location, params }) {
  const { window } = globals;
  return getFromObject({
    arrayIndices,
    location,
    object: urlQuery.parse(window.location.search.slice(1)),
    operator: '_url_query',
    params,
  });
}

# URL: ?user=john&id=123
userId:
  _url_query: id # Returns "123"

_initInput = () => {
  this.setValue = (value) => {
    // Type enforcement
    this.value = type.enforceType(this.meta.valueType, value);

    // Store in state
    this.context._internal.State.set(this.blockId, this.value);

    // Mark for re-render
    this.update = true;
    this.context._internal.update();
  };
};

User types in input
        ↓
Block component calls block.setValue(newValue)
        ↓
Type enforced via block metadata
        ↓
State.set(blockId, value)
        ↓
block.update = true
        ↓
context._internal.update()
        ↓
Areas.updateStateFromRoot()
        ↓
Block.evaluate() for all blocks
        ↓
React re-render

update = () => {
  this.updateStateFromRoot();
  this.renderBlocks();
};

updateStateFromRoot = () => {
  const repeat = this.recEval(true);
  this.updateState();

  // Re-evaluate if visibility changed (max 20 iterations)
  if (repeat && this.recCount < 20) {
    this.recCount += 1;
    this.updateStateFromRoot();
  }
};

evaluate = (visibleParent, repeat) => {
  // Sync state value for input blocks
  if (this.isInput()) {
    const stateValue = get(this.context.state, this.blockId);
    this.value = type.isUndefined(stateValue) ? this.value : stateValue;
  }

  // Evaluate all expressions
  this.propertiesEval = this.parse(this.properties);
  this.styleEval = this.parse(this.style);
  this.visibleEval = this.parse(this.visible);

  // Mark for render if changed
  if (this.before !== after) {
    this.update = true;
  }
};

function createSetState({ arrayIndices, context }) {
  return function setState(params) {
    Object.keys(params).forEach((key) => {
      context._internal.State.set(applyArrayIndices(arrayIndices, key), params[key]);
    });
    context._internal.RootAreas.reset();
    context._internal.update();
  };
}

events:
  onClick:
    - id: setUser
      type: SetState
      params:
        user:
          name: John
          email: [email protected]

function createReset({ context }) {
  return function reset() {
    context._internal.State.resetState();
    context._internal.RootAreas.reset(deserializeFromString(context._internal.State.frozenState));
  };
}

this.pushItem = () => {
  this.subAreas.push(
    this.newAreas({ arrayIndices: [...], initState: {} })
  );
  this.update = true;
  this.context._internal.update();
};

this.removeItem = (index) => {
  this.context._internal.State.removeItem(this.blockId, index);
  this.subAreas.splice(index, 1);
  // Re-index remaining items
  this.update = true;
  this.context._internal.update();
};

async callRequest({ actions, arrayIndices, blockId, event, requestId }) {
  const requestConfig = this.requestConfig[requestId];

  // Parse payload - resolves all operators including _state
  const { output: payload } = this.context._internal.parser.parse({
    actions,
    event,
    arrayIndices,
    input: requestConfig.payload,
    location: requestId,
  });

  return this.fetch({ payload, requestId, ... });
}

requests:
  - id: saveUser
    type: MongoDBUpdateOne
    connectionId: mongodb
    payload:
      filter:
        _id:
          _state: selectedUserId
      update:
        $set:
          name:
            _state: form.name
          email:
            _state: form.email

const Block = ({ block, Blocks, context, lowdefy, parentLoading }) => {
  const [updates, setUpdate] = useState(0);

  // Register updater in lowdefy context
  lowdefy._internal.updaters[block.id] = () => setUpdate(updates + 1);

  // Re-render when state changes trigger update
  return <CategorySwitch ... />;
};

State.set() called
        ↓
context._internal.update()
        ↓
Areas.updateStateFromRoot()
        ↓
Block.evaluate() computes new values
        ↓
lowdefy._internal.updateBlock(blockId)
        ↓
lowdefy._internal.updaters[blockId]()
        ↓
React useState triggers re-render

get(object, 'user.profile.name', { default: null, copy: true });

// Supports:
// - Dot notation: 'a.b.c'
// - Array indices: 'items.0.name'
// - Default values
// - Deep copy option

set(state, 'user.profile.name', 'John');

// Features:
// - Auto-creates intermediate objects
// - Handles array index paths
// - Prevents prototype pollution

type.enforceType('string', value);
type.enforceType('array', value);
type.enforceType('object', value);