@lowdefy/shell 0.0.0-experimental-20261019052246

package/src/dev/steps/createStepRunner.test.js

@@ -0,0 +1,262 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import React from 'react';
+import { jest } from '@jest/globals';
+import { Pressable, Text, View } from 'react-native';
+import { act, fireEvent, render, screen } from '@testing-library/react-native';
+import { createNativeGlobals, LowdefyPage } from '@lowdefy/client-native';
+import { SetState } from '@lowdefy/actions-core/actions';
+import { _state } from '@lowdefy/operators-js/operators/client';
+
+import createMemoryStore from '../../host/createMemoryStore.js';
+import createStepRunner from './createStepRunner.js';
+
+// Stand-ins for native blocks: a container, a button, a text input and a selector.
+function Box({ content }) {
+  return <View>{content.content?.()}</View>;
+}
+Box.meta = { category: 'container', slots: { content: 'Child blocks.' } };
+
+function Button({ methods, properties }) {
+  return (
+    <Pressable accessibilityRole="button" onPress={() => methods.triggerEvent({ name: 'onClick' })}>
+      <Text>{properties.title}</Text>
+    </Pressable>
+  );
+}
+Button.meta = { category: 'display' };
+
+function TextInput({ blockId, value }) {
+  return <Text testID={`${blockId}-value`}>{value ?? ''}</Text>;
+}
+TextInput.meta = { category: 'input', valueType: 'string' };
+
+function Selector({ blockId, value }) {
+  return <Text testID={`${blockId}-value`}>{JSON.stringify(value ?? null)}</Text>;
+}
+Selector.meta = { category: 'input', valueType: 'any' };
+
+// An action that takes a while, so a step that returns before its chain ends would be seen.
+function Pause({ params }) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, params.ms);
+  });
+}
+
+const types = {
+  actions: { Pause, SetState },
+  blocks: { Box, Button, Selector, TextInput },
+  operators: { _state },
+};
+
+function block({ id, type, events, ...rest }) {
+  const built = { id: `block:form:${id}:0`, blockId: id, type, ...rest };
+  if (events) {
+    built.events = Object.fromEntries(
+      Object.entries(events).map(([name, actions]) => [name, { try: actions, catch: [] }])
+    );
+  }
+  return built;
+}
+
+const pageConfig = {
+  id: 'page:form',
+  pageId: 'form',
+  blockId: 'form',
+  type: 'Box',
+  path: 'form',
+  linkPaths: {},
+  subscriptions: [],
+  requests: [],
+  slots: {
+    content: {
+      blocks: [
+        block({
+          id: 'title',
+          type: 'TextInput',
+          events: {
+            onChange: [{ id: 'echo', type: 'SetState', params: { echo: { _state: 'title' } } }],
+            onPressEnter: [{ id: 'enter', type: 'SetState', params: { entered: true } }],
+          },
+        }),
+        block({
+          id: 'priority',
+          type: 'Selector',
+          properties: {
+            options: [
+              { label: 'Low', value: 'low' },
+              { label: 'High', value: 'high' },
+            ],
+          },
+        }),
+        block({
+          id: 'save',
+          type: 'Button',
+          properties: { title: 'Save' },
+          events: {
+            onClick: [
+              { id: 'pause', type: 'Pause', params: { ms: 200 } },
+              { id: 'saved', type: 'SetState', params: { saved: true } },
+            ],
+          },
+        }),
+        block({ id: 'locked', type: 'Button', properties: { title: 'Locked', disabled: true } }),
+        block({ id: 'hidden', type: 'Button', visible: false, properties: { title: 'Hidden' } }),
+      ],
+    },
+  },
+};
+
+const rootConfig = {
+  classMap: {},
+  home: { configured: true, pageId: 'form' },
+  lowdefyApp: { slug: 'test-app' },
+  menus: [],
+  pagePaths: { form: 'form' },
+  theme: { light: {}, dark: {} },
+};
+
+async function renderForm() {
+  const fetch = jest.fn();
+  const host = {
+    fetch,
+    globals: createNativeGlobals({
+      assign: jest.fn(),
+      fetch,
+      getPath: () => '/form',
+      origin: 'https://app.lowdefy.test',
+    }),
+    onBuildChanged: jest.fn(),
+    onCallerChanged: jest.fn(),
+    router: { back: jest.fn(), push: jest.fn(), replace: jest.fn() },
+    sessionStorage: createMemoryStore(),
+    storage: createMemoryStore(),
+    WebSocket: jest.fn(),
+    websocketUrl: (apiPath) => apiPath,
+  };
+  const lowdefy = {};
+  const core = {
+    apiBase: 'https://app.lowdefy.test',
+    auth: { authConfig: {} },
+    basePath: '',
+    lowdefy,
+  };
+  await render(
+    <LowdefyPage
+      core={core}
+      host={host}
+      pageConfig={pageConfig}
+      rootConfig={rootConfig}
+      types={types}
+    />
+  );
+  await screen.findByText('Save');
+  const capture = jest.fn(async () => 'iVBORw0KGgo=');
+  const runner = createStepRunner({ capture, getLowdefy: () => lowdefy, timeout: 300 });
+  const state = () => lowdefy.contexts['page:form'].state;
+  async function run(step) {
+    let result;
+    await act(async () => {
+      result = await runner.run({ step });
+    });
+    return result;
+  }
+  async function fail(step) {
+    let error;
+    await act(async () => {
+      error = await runner.run({ step }).catch((caught) => caught);
+    });
+    return error.message;
+  }
+  return { capture, fail, run, state };
+}
+
+test('a click step finds the block by the id its view carries as testID and waits for its action chain', async () => {
+  const { run, state } = await renderForm();
+  expect(screen.getByTestId('save')).toBeTruthy();
+  const result = await run({ click: 'save' });
+  expect(result).toEqual({ ok: true, settled: true });
+  expect(state().saved).toBe(true);
+});
+
+test('a click step takes a { blockId } target', async () => {
+  const { run, state } = await renderForm();
+  await run({ click: { blockId: 'save' } });
+  expect(state().saved).toBe(true);
+});
+
+test('a fill step sets an input and runs its onChange, which the page then shows', async () => {
+  const { run, state } = await renderForm();
+  await run({ fill: { blockId: 'title', value: 'Quarterly' } });
+  expect(state().title).toBe('Quarterly');
+  expect(state().echo).toBe('Quarterly');
+  expect(screen.getByTestId('title-value').props.children).toBe('Quarterly');
+});
+
+test('a press Enter step runs the onPressEnter of the input filled last', async () => {
+  const { run, state } = await renderForm();
+  await run({ fill: { blockId: 'title', value: 'Quarterly' } });
+  await run({ press: 'Enter' });
+  expect(state().entered).toBe(true);
+});
+
+test('a select step picks the option by its label', async () => {
+  const { run, state } = await renderForm();
+  await run({ select: { blockId: 'priority', value: 'High' } });
+  expect(state().priority).toBe('high');
+});
+
+test('a wait step waits for state to be set', async () => {
+  const { run, state } = await renderForm();
+  await act(async () => {
+    fireEvent.press(screen.getByText('Save'));
+  });
+  expect(state().saved).toBeUndefined();
+  expect(await run({ wait: { state: 'saved' } })).toEqual({ ok: true });
+  expect(state().saved).toBe(true);
+});
+
+test('a screenshot step captures the root view', async () => {
+  const { capture, run } = await renderForm();
+  expect(await run({ screenshot: 'after-save' })).toEqual({
+    ok: true,
+    name: 'after-save',
+    image: 'iVBORw0KGgo=',
+  });
+  expect(capture).toHaveBeenCalledTimes(1);
+});
+
+test('steps that cannot run say why', async () => {
+  const { fail } = await renderForm();
+  expect(await fail({ click: 'missing' })).toBe(
+    'Block "missing" is not on page "form". Waited 300 ms.'
+  );
+  expect(await fail({ click: 'hidden' })).toBe('Block "hidden" is not visible. Waited 300 ms.');
+  expect(await fail({ click: 'locked' })).toBe('Block "locked" is disabled.');
+  expect(await fail({ fill: { blockId: 'save', value: 'x' } })).toBe(
+    'Block "save" is not an input.'
+  );
+  expect(await fail({ select: { blockId: 'priority', value: 'Urgent' } })).toBe(
+    'Block "priority" has no option "Urgent". Its options are ["Low","High"].'
+  );
+  expect(await fail({ press: 'Enter' })).toBe('Press "Enter" needs an input filled before it.');
+  expect(await fail({ press: 'Tab' })).toBe('A phone presses only "Enter". Received "Tab".');
+  expect(await fail({ click: { blockId: 'save', text: 'Save' } })).toMatch(/by blockId only/);
+  expect(await fail({ goto: 'home' })).toBe(
+    'A phone runs the steps click, fill, select, press, wait, screenshot. Received "goto".'
+  );
+});

package/src/dev/steps/findBlock.js

@@ -0,0 +1,78 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { type } from '@lowdefy/helpers';
+
+import findPageContext from '../tab/findPageContext.js';
+import getShownPage from '../tab/getShownPage.js';
+import waitUntil from './waitUntil.js';
+
+// A step's target: a block id, or `{ blockId }`. The browser's grid, text and nth targets read the
+// DOM, which a phone does not have.
+function readBlockId(target) {
+  if (type.isString(target)) {
+    return target;
+  }
+  if (type.isObject(target) && type.isString(target.blockId)) {
+    const others = Object.keys(target).filter((key) => !['blockId', 'value'].includes(key));
+    if (others.length > 0) {
+      throw new Error(
+        `A step on a phone targets a block by blockId only. Received ${JSON.stringify(target)}.`
+      );
+    }
+    return target.blockId;
+  }
+  throw new Error(
+    `A step target must be a blockId or { blockId }. Received ${JSON.stringify(target)}.`
+  );
+}
+
+/**
+ * The block a step acts on, on the page the shell shows: `{ block, context, page }`. Its view is
+ * the one with the block id as testID (client-native BlockLayout), so a step needs no screen
+ * position. Waits up to `timeout` ms for the page to render the block and show it.
+ */
+async function findBlock({ lowdefy, target, timeout }) {
+  const blockId = readBlockId(target);
+  let lastError = null;
+  const found = await waitUntil({
+    timeout,
+    check: () => {
+      const page = getShownPage(lowdefy);
+      const { context, error } = findPageContext({ lowdefy, page });
+      if (error) {
+        lastError = error;
+        return undefined;
+      }
+      const block = context._internal.RootSlots?.map?.[blockId];
+      if (type.isNone(block)) {
+        lastError = `Block "${blockId}" is not on page "${page.pageId}".`;
+        return undefined;
+      }
+      if (block.eval?.visible === false) {
+        lastError = `Block "${blockId}" is not visible.`;
+        return undefined;
+      }
+      return { block, context, page };
+    },
+  });
+  if (found === undefined) {
+    throw new Error(`${lastError} Waited ${timeout} ms.`);
+  }
+  return found;
+}
+
+export default findBlock;

package/src/dev/steps/isContextSettled.js

@@ -0,0 +1,37 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// A page context with nothing left running: its onInit and onInitAsync (and the app's) are done, no
+// block event is running (an onClick's action chain, an onMountAsync), no request is loading and
+// every subscription has connected or failed. The dev server's isPageReady reads a browser tab the
+// same way.
+function isContextSettled({ context, lowdefy }) {
+  if (context._internal?.onInitDone !== true) return false;
+  if (context._internal?.onInitAsyncDone !== true) return false;
+  const appContext = lowdefy.appContext;
+  if (appContext && appContext._internal?.onInitAsyncDone !== true) return false;
+  const blocks = Object.values(context._internal?.RootSlots?.map ?? {});
+  const running = blocks.some((block) =>
+    Object.values(block?.Events?.events ?? {}).some((event) => event?.loading === true)
+  );
+  if (running) return false;
+  const requests = Object.values(context.requests ?? {});
+  if (requests.some((calls) => calls?.[0]?.loading)) return false;
+  const channels = Object.values(context.websockets ?? {});
+  return channels.every((channel) => channel?.connected === true || Boolean(channel?.error));
+}
+
+export default isContextSettled;

package/src/dev/steps/waitForSettle.js

@@ -0,0 +1,39 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import findPageContext from '../tab/findPageContext.js';
+import getShownPage from '../tab/getShownPage.js';
+import isContextSettled from './isContextSettled.js';
+import waitUntil from './waitUntil.js';
+
+// Waits, at most `timeout` ms, for the page the shell shows (it may have changed: a click can open
+// another page) to finish what an interaction started. True once settled; false when it is still
+// busy, which, as in the browser runner, does not fail the step.
+async function waitForSettle({ lowdefy, timeout }) {
+  const settled = await waitUntil({
+    timeout,
+    check: () => {
+      const { context } = findPageContext({ lowdefy, page: getShownPage(lowdefy) });
+      if (context === undefined || !isContextSettled({ context, lowdefy })) {
+        return undefined;
+      }
+      return true;
+    },
+  });
+  return settled === true;
+}
+
+export default waitForSettle;

package/src/dev/steps/waitUntil.js

@@ -0,0 +1,40 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+const POLL_MS = 50;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Calls check every 50 ms until it returns a value other than undefined, and resolves with it, or
+// with undefined once `timeout` ms have passed.
+async function waitUntil({ check, timeout }) {
+  const deadline = Date.now() + timeout;
+  for (;;) {
+    const value = check();
+    if (value !== undefined) {
+      return value;
+    }
+    if (Date.now() >= deadline) {
+      return undefined;
+    }
+    await sleep(POLL_MS);
+  }
+}
+
+export { sleep };
+export default waitUntil;

package/src/dev/tab/DevTabClient.js

@@ -0,0 +1,97 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { useEffect } from 'react';
+import { Platform } from 'react-native';
+import { fetch as expoFetch } from 'expo/fetch';
+import { captureRef } from 'react-native-view-shot';
+
+import createDevTabClient from './createDevTabClient.js';
+import createNativeRecorder from '../recorder/createNativeRecorder.js';
+import createStepRunner from '../steps/createStepRunner.js';
+import reloadApp from './reloadApp.js';
+import withShellHeader from '../../host/withShellHeader.js';
+import { useShell } from '../../ShellContext.js';
+
+/**
+ * Joins the dev server's tab channel for the app that is open (createDevTabClient), records what
+ * the developer does in it (createNativeRecorder), and tells Lowdefy Dev which app that is through
+ * onApp, so the shake menu can reload it or clear its data. Rendered inside the app's provider;
+ * draws nothing.
+ *
+ * @param {Object} props
+ * @param {Object} props.injections The device injections (createDeviceInjections).
+ * @param {Object} props.kv The device store.
+ * @param {Object} props.logs The log buffer (createLogBuffer).
+ * @param {(app: Object|null) => void} props.onApp
+ * @param {{ current: Object }} props.rootRef The view the whole app is drawn in, for screenshots.
+ */
+function DevTabClient({ injections, kv, logs, onApp, rootRef }) {
+  const app = useShell();
+  const { session, shell } = app;
+
+  useEffect(() => {
+    onApp(app);
+    return () => onApp(null);
+  }, [app, onApp]);
+
+  useEffect(() => {
+    const getLowdefy = () => session.getState().lowdefy;
+    const withHeaders = (fetch) =>
+      withShellHeader({ fetch: shell.transport.wrapFetch(fetch), shellVersion: shell.version });
+    const runner = createStepRunner({
+      capture: () => captureRef(rootRef, { format: 'png', result: 'base64' }),
+      getLowdefy,
+    });
+    const fetch = withHeaders(globalThis.fetch);
+    const recorder = createNativeRecorder({
+      apiBase: session.apiBase,
+      device: Platform.OS,
+      fetch,
+      getBuild: () => session.getState().buildId ?? null,
+      getLowdefy,
+      kv,
+      shellVersion: shell.version,
+    });
+    const client = createDevTabClient({
+      apiBase: session.apiBase,
+      device: {
+        platform: Platform.OS,
+        app: Platform.OS === 'ios' ? shell.ios?.bundleIdentifier : shell.android?.package,
+      },
+      fetch,
+      getLowdefy,
+      log: (message) => logs.add('info', message),
+      onInject: ({ injection }) => injections.inject(injection ?? {}),
+      onReload: async () => {
+        await recorder.flush();
+        await reloadApp({ session });
+      },
+      onStep: ({ step }) => runner.run({ step }),
+      streamFetch: withHeaders(expoFetch),
+    });
+    recorder.start();
+    client.start();
+    return () => {
+      client.stop();
+      recorder.stop();
+    };
+  }, [injections, kv, logs, rootRef, session, shell]);
+
+  return null;
+}
+
+export default DevTabClient;

package/src/dev/tab/answerEval.js

@@ -0,0 +1,39 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { serializer, type } from '@lowdefy/helpers';
+
+import findPageContext from './findPageContext.js';
+
+/**
+ * The answer to an eval-request: the operator expression evaluated with the page instance's own
+ * parser, `{ value, errors }`, as a browser tab answers it (server-dev client/Inspector.jsx). The
+ * expression may arrive as JSON text, as an MCP tool argument passes it.
+ */
+function answerEval({ expression, lowdefy, page }) {
+  const { context, error } = findPageContext({ lowdefy, page });
+  if (error) {
+    return { error };
+  }
+  const input = type.isString(expression) ? JSON.parse(expression) : expression;
+  const { output, errors } = context._internal.parser.parse({ input, location: 'agent_eval' });
+  return {
+    value: serializer.serializeToString(output),
+    errors: errors.map((parseError) => parseError.message),
+  };
+}
+
+export default answerEval;

package/src/dev/tab/answerInspect.js

@@ -0,0 +1,45 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { serializer } from '@lowdefy/helpers';
+
+import findPageContext from './findPageContext.js';
+
+/**
+ * The answer to an inspect-request: the page instance's live state, as a browser tab answers it
+ * (server-dev client/Inspector.jsx), a serialized string the dev server deserializes
+ * (lib/docs/inspectStateFromTab.js). The URL query is the shown route's.
+ */
+function answerInspect({ lowdefy, page }) {
+  const { context, error } = findPageContext({ lowdefy, page });
+  if (error) {
+    return { error };
+  }
+  return serializer.serializeToString({
+    pageId: page.pageId,
+    pathParams: context.pathParams,
+    instanceKey: page.instanceKey,
+    state: context.state,
+    requests: context.requests,
+    eventLog: (context.eventLog ?? []).slice(-50),
+    global: lowdefy.lowdefyGlobal,
+    user: lowdefy.user,
+    input: lowdefy.inputs?.[page.instanceKey],
+    urlQuery: lowdefy._internal.globals.window.location.search,
+  });
+}
+
+export default answerInspect;

package/src/dev/tab/answerLoadState.js

@@ -0,0 +1,50 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { type } from '@lowdefy/helpers';
+
+import findPageContext from './findPageContext.js';
+
+/**
+ * The answer to a load-state-request (server-dev lib/docs/loadState.js, with a device): sets each
+ * key of a state checkpoint on the page instance's state and re-renders it, as the dev server does
+ * in its headless browser, then reads back the first `verify` keys so the agent sees they landed.
+ * Answers `{ verifiedKeys }`, or `{ error }` as a browser tab words it.
+ */
+function answerLoadState({ lowdefy, page, state, verify = 3 }) {
+  if (!type.isObject(state)) {
+    return {
+      error: `A load-state-request needs the state as an object. Received ${JSON.stringify(
+        state
+      )}.`,
+    };
+  }
+  const { context, error } = findPageContext({ lowdefy, page });
+  if (error) {
+    return { error };
+  }
+  const entries = Object.entries(state);
+  entries.forEach(([key, value]) => {
+    context._internal.State.set(key, value);
+  });
+  context._internal.update();
+  const verifiedKeys = Object.fromEntries(
+    entries.slice(0, verify).map(([key]) => [key, context.state?.[key]])
+  );
+  return { verifiedKeys };
+}
+
+export default answerLoadState;