@toloka-platform/sdk 0.1.0-preview.5 → 0.1.0-preview.7

package/skills/toloka-build/references/workflow-and-cli.md

@@ -26,14 +26,17 @@ Treat the three layers differently:
 
 ## Initialize the source root
 
-Install the SDK in the project, then initialize the directory before selecting a platform project:
+For a first-time guided session, read `https://platform.toloka.ai/onboarding.md` first. Keep its stage order and checkpoints; use this reference for the commands and source-first invariants inside those stages.
+
+Install the SDK before invoking project commands:
 
 ```sh
 bun add --dev @toloka-platform/sdk
-toloka init
 ```
 
-`init` does not require a selected project. It checks that `@toloka-platform/sdk` is declared in `dependencies` or `devDependencies`, then maintains one `<toloka>` Agent Bootstrap block in `AGENTS.md` and writes minimal pointers to it: a Claude skill at `.claude/skills/toloka-bootstrap/SKILL.md` when `.claude/` exists (or when no agent configuration exists at all) and an always-applied Cursor rule at `.cursor/rules/toloka-bootstrap.mdc` when `.cursor/rules/` exists. If a project is already selected through `--project-id`, `TOLOKA_PROJECT_ID` / `POTATO_PROJECT_ID`, `toloka.json`, or the machine registry, it also writes `toloka.json` when missing.
+Select or create the intended platform project before `toloka init` when the checkout should be bound immediately; follow the adoption or scratch recipe below. Running `init` without explicit or checkout-local project identity installs only the agent entry points and never adopts the machine registry's current project.
+
+`toloka init` checks that `@toloka-platform/sdk` is declared in `dependencies` or `devDependencies`, then maintains one `<toloka>` Agent Bootstrap block in `AGENTS.md` and writes minimal pointers to it: a Claude skill at `.claude/skills/toloka-bootstrap/SKILL.md` when `.claude/` exists (or when no agent configuration exists at all) and an always-applied Cursor rule at `.cursor/rules/toloka-bootstrap.mdc` when `.cursor/rules/` exists. It writes `toloka.json` only from an explicit project flag/environment value or an existing checkout binding.
 
 The bootstrap is small: it tells an agent to run `toloka --help`, search the bundled Skill Catalog with `toloka skill search <query>`, install the match with `toloka skill install <skill-id>`, and read `.agents/skills/<skill-id>/SKILL.md`. This skill is that installed copy. Commands warn on stderr when a generated legacy entry point is still present or the recorded bootstrap version differs from the installed SDK. Help, `init`, `report`, `project url`, and version invocations skip this checkout-dependent warning. The warning never blocks a command; re-run `toloka init` to refresh the bootstrap and its pointers.
 
@@ -84,7 +87,7 @@ toloka --version
 toloka login
 toloka logout
 toloka auth-status
-toloka project list
+toloka project list [--limit <n>]
 toloka project add [alias] [projectId]
 toloka project switch <alias>
 toloka project current
@@ -93,6 +96,7 @@ toloka project remove <alias>
 toloka project create [alias] [--name <name>] [--team-id <id>]
 toloka init
 toloka import [projectId]
+toloka check [pipeline] [--node <name-or-id>] [--json] [--watch]
 toloka validate
 toloka plan
 toloka apply
@@ -102,60 +106,76 @@ toloka dataset list
 toloka dataset fields <name>
 toloka dataset load <name> --out <file> [--limit <n>] [--timeout <ms>]
 toloka dataset upload <name> <file>
-toloka pipeline list
+toloka pipeline list [--limit <n>]
 toloka pipeline run [name] [--wait] [--timeout <ms>]
 toloka pipeline status [name]
 toloka pipeline runs [name] [--limit <n>]
 toloka pipeline cost [name] [--item-limit <n>]
 toloka pipeline results <runId> [--limit <n>] [--failed]
 toloka pipeline cancel <runId>
+toloka base-model list [--json]
+toloka base-model get <id> [--json]
+toloka model list [--json]
+toloka model get <name-or-id> [--json]
+toloka model versions <name-or-id> [--json]
+toloka model create <name> --base <base-model-id> [--description <text>] [--json]
+toloka model archive <name-or-id> [--json]
 toloka skill list [--json]
 toloka skill search <query> [--json]
 toloka skill install <skill-id> [--force]
 toloka report <markdown> [--authored-by human|agent] [--confirm]
 ```
 
-Select the platform project with `toloka project add` or `toloka project create` before `import`, `plan`, or `apply`. `init` may run first, and `import` uses the selected project when the id is omitted.
+Select the platform project with `toloka project add` or `toloka project create` before `import`, `plan`, or `apply`. For `init`, `toloka --project-id <id> init`, `TOLOKA_PROJECT_ID`, and `POTATO_PROJECT_ID` bind an empty checkout directly without changing the machine registry. `project create` also writes `toloka.json`; `project add` changes only the machine registry, so follow it with `import <projectId>` for an existing project or an explicit project ID on `init` for an empty one. Confirm `toloka project current` and `toloka.json` resolve to the intended ID before authoring.
 
 `toloka project url` prints only the selected project's platform UI URL. Use it when the user needs a working link to inspect the live project.
 
-`toloka pipeline cost [name] [--item-limit <n>]` forecasts what a run of a live pipeline would bill. It does not start a run and does not change the graph. Name the live pipeline or id; a TTY may pick among several. The typed client equivalent is `client.pipelines.estimateCost({ pipelineId, itemLimit? })`.
+`toloka pipeline cost [name] [--item-limit <n>]` forecasts what a run of a live, validated pipeline would bill. It does not start a run or change the graph. If any billed node is marked `skipped`, the displayed total is incomplete and must not be presented as the pipeline price. Compute and label a labor floor for each skipped billed node as `items × pricePerTask × annotations per item`, using `1` for generation and `overlap` for quorum. Also report `maxEntities`, quality-criteria count, and only exclusions applicable to the authored QA and workflow. Apply accepting a rate does not prove its final billed value.
+
+## Manage model checkpoints
+
+The global Base Model Catalog is read-only and uses `toloka base-model`. `base-model list` prints aligned ID, name, provider, and upstream-model columns by default. `toloka model` manages project-owned lineages; creation requires one catalog `baseModelId` and creates metadata without a Model Version. Every Base Model and Model command accepts `--json` for machine-readable output. Model Version upload, validation, and download commands are deferred until the separate upload-processing contract is implemented.
 
 ## Adopt an existing live project
 
-1. Run `toloka init` in the intended source root if the agent entry points are not installed yet.
-2. Run `toloka project add <alias> <projectId>`.
-3. Run `toloka import`.
-4. Inspect `toloka.json` and every generated `pipelines/**/pipeline.ts` dependency before editing.
-5. Preserve generated constructor `id` options. They bind imported source to the existing graph; never copy them to unrelated declarations or invent replacements.
-6. Make the smallest source change, validate offline, plan, apply, and plan again.
+1. Install `@toloka-platform/sdk` in the intended source root.
+2. Run `toloka project add <alias> <projectId>`, or `toloka project switch <alias>` when the project is already registered.
+3. Run `toloka import` into the empty source root.
+4. Run `toloka init` to install or refresh the agent entry points without rebinding project identity.
+5. Confirm `toloka.json.projectId` equals `toloka project current`, then run `toloka plan` before editing and require `No changes.`. A non-empty baseline is importer or live-state drift to understand separately from your change.
+6. Inspect every generated `pipelines/**/pipeline.ts` dependency, preserve constructor `id` options that bind source to the existing graph, and make the smallest source change.
+7. Validate offline, plan, apply, and plan again. Never copy imported IDs to unrelated declarations or invent replacements.
 
 Import refuses an existing `pipelines/` directory. Pass `--force` to replace it with the live graph as TypeScript. Never use `--force` as a harmless refresh over uncommitted source work.
 
 ## Author against a project from scratch
 
-1. Run `toloka init` in the intended source root if the agent entry points are not installed yet.
-2. Run `toloka project create <alias>` or `toloka project add <alias> <projectId>`.
+1. Run `toloka project create <alias>` for a new project, or `toloka project add <alias> <projectId>` for an existing empty project.
+2. Run `toloka init` after creation. For an existing empty project, run `toloka --project-id <projectId> init`. Then require `toloka project current` and `toloka.json` to name the same project.
 3. Create `pipelines/<name>/pipeline.ts` and its imported modules.
 4. Default-export `definePipeline({ dataset, fields, nodes, connections })`.
-5. Run `toloka validate`.
-6. Run `toloka plan`.
-7. Resolve missing secrets and immutable-field conflicts.
-8. Run `toloka apply`.
+5. Add typed node and pipeline-flow tests, then run `toloka check`.
+6. Run `toloka validate`; a not-yet-created pipeline is reported as skipped, not server-validated.
+7. Run `toloka plan` and resolve missing secrets or immutable-field conflicts.
+8. Run `toloka apply`; it reruns `toloka check` before any platform write.
 9. Require a final `toloka plan` to print `No changes.`
 
 On first apply, the CLI creates each missing named dataset, adds fields required by the authored graphs, creates each missing pipeline, attaches its dataset, and records the resolved IDs. Two pipelines that name the same dataset contribute the union of their required fields.
 
-## Validate against the platform
+## Check locally and validate against the platform
 
-Run the project typecheck first. Then validate every bound pipeline:
+Run the complete local gate first, then validate every bound pipeline remotely:
 
 ```sh
-bunx tsc --noEmit
+toloka check
 toloka validate
 ```
 
-`toloka validate` posts each authored graph to the platform. It reports spec errors, warnings, and the latest matching check jobs. It does not write the graph. A pipeline that is not on the platform yet is skipped until `toloka apply` creates it.
+`toloka check` requires no credentials or live pipeline. It loads source, runs the project TypeScript compiler, typechecks every Task UI against the SDK's bundled declarations, runs Vitest, and compares passing typed test evidence with every checkable node and pipeline. Use `toloka check <pipeline> --node <name-or-id>` for a focused edit loop, `--watch` for serialized reruns, and `--json` for automation. `missing` means required evidence was not produced; `failed` means a check ran and failed; `partial` means hardware-backed behavior remains unverified; `infrastructure_error` means a required tool, browser, or launcher could not run. All four block apply.
+
+With `--watch --json`, each completed rerun writes one JSON line. Do not start another watcher while one is active.
+
+`toloka validate` posts each authored graph to the platform. Distinguish source/spec errors, which require source changes; `not_ran_node_check`, which describes a separate Remote Node Check; and warnings. It does not write the graph. A pipeline that is not on the platform yet is skipped until `toloka apply` creates it. When plan adds a dataset field used by an already-live pipeline, pre-apply validation can report that exact field as `misconfigured_node_form_component` because the column is not live yet. Treat it as expected only when the reviewed plan adds the same field, then require post-apply validation to clear the source/spec error.
 
 The authored API still supplies extra local safety:
 
@@ -164,7 +184,7 @@ The authored API still supplies extra local safety:
 - It rejects a `connect()` endpoint whose node is absent from `nodes`.
 - Typed ports prevent reversing input and output handles.
 
-These checks do not replace `toloka validate`. Plan compares source with live resources but does not submit the desired graph for acceptance. Apply is where the backend can reject graph-wide references, layout identity, or concurrent-version assumptions.
+`toloka apply` runs the full Local Check Gate again before resolving credentials or writing platform state. Plan compares source with live resources but does not submit the desired graph for acceptance. Apply can still expose graph-wide references, layout identity, or concurrent-version assumptions that only the backend owns.
 
 ## Read and apply a plan
 
@@ -178,6 +198,20 @@ Treat every plan line as evidence of what apply will attempt.
 
 Apply preserves existing live layout and the root's live item filter. Do not add either to authored source. For graph replacement, apply reads the live graph version and sends it as `expectedVersion`; never put a version in source or state yourself.
 
+## Test pipeline nodes locally
+
+Register every code-node behavior with `test.code(pipeline, node, name, callback)`. Its callback receives a bound `run(inputs, options?)` helper with the same Python execution contract as `runCodeNode`; the test counts only after the bound executor runs, an assertion executes, and the callback passes.
+
+Before choosing component names or props, call `ui.componentDocumentation()` in a local `@toloka-platform/sdk/testing` scenario. A component's contract is its returned `propsType`, `valueType`, and `example`. For structured or array-valued Fields, derive the dataset field schema from `valueType`, then feed the documented example value through `setValue`, `getValue`, and `submit`; never translate undocumented property names or replace missing values with defaults. Register required human-work behavior with `test.ui(pipeline, node, name, callback)`. Its callback receives bound `render(options?)`; the test counts only after a successful `submit`, at least one assertion, and a passing callback.
+
+Register the representative connected flow with `test.pipeline(pipeline, name, callback)`. When a local dataset file is available, use its first row as the initial item state; redact sensitive values while preserving field names, nesting, optionality, and media/value shapes. Use synthetic input only when no local row exists. Use the callback's bound `runCode` and `renderUi` helpers, merge only declared node outputs, and assert the final `root.completed` fields. Keep a linear happy path in one test; use separate scenarios for match branches, optional routes, and failures.
+
+```sh
+toloka check
+```
+
+Plain Vitest tests still run and can fail the command, but only typed Toloka wrappers satisfy required node and pipeline coverage. Use synthetic or redacted data. `preprocess` and `postprocess` remain runtime JavaScript function bodies, not TypeScript.
+
 ## Add dataset rows
 
 Declare the fields in source, then upload rows:
@@ -186,7 +220,9 @@ Declare the fields in source, then upload rows:
 toloka dataset upload <dataset> <file>
 ```
 
-The input file is JSONL: each non-empty line must parse as one JSON object. The dataset does not have to exist yet: when a pipeline in source binds it, upload creates it and declares that pipeline's columns, so rows land in real columns rather than in the raw `uploaded` blob. Upload refuses when no pipeline in source declares a name because it would have no column names to map onto. An id-shaped argument is never created; upload fails when that dataset id does not exist in the project. Upload appends items; apply never uploads, replaces, or deletes rows. Duplicate live names must be addressed by id.
+The upload file path resolves from the command process's working directory, not from `--source-root`. Use an absolute path when the command runs elsewhere.
+
+The CLI infers the input format from its extension and uploads the original bytes without conversion: `.json` is an array of row objects, `.jsonl` has one object per non-empty line, and `.csv` uses its header row as field names with every value ingested as a string. JSONL is validated locally before upload. If transfer or finalization fails, the CLI cancels the started upload before returning the error, so another upload can start immediately and may reuse the same filename. The dataset does not have to exist yet: when a pipeline in source binds it, upload creates it and declares that pipeline's columns, so rows land in real columns rather than in the raw `uploaded` blob. Upload refuses when no pipeline in source declares a name because it would have no column names to map onto. An id-shaped argument is never created; upload fails when that dataset id does not exist in the project. Upload appends items; applying source never deletes them.
 
 If a later upload fails with a schema-incompatibility error, inspect the inferred schema from the first successful upload:
 
@@ -194,7 +230,7 @@ If a later upload fails with a schema-incompatibility error, inspect the inferre
 toloka dataset fields <dataset>
 ```
 
-That prints `field()` declarations for the top-level inferred columns. Copy them into source when you want authored fields to match the stored inference. It does not write source or mutate the dataset.
+That prints `field()` declarations for the top-level inferred columns. Use the output to recover stored names and base types, but do not copy it wholesale over stricter source schemas: inference can omit enum, length, range, and format constraints. It does not write source or mutate the dataset.
 
 Keep item files outside the source tree or gitignored. Never embed sample or production rows in `pipeline.ts` to make reconciliation create them.
 
@@ -258,9 +294,13 @@ Use the exact name reported by plan. Set it with `toloka secret set`, rerun plan
 
 A 409 means live graph state changed after apply read it. Run plan again, compare the new live diff with the source, incorporate intentional live changes into source when required, and apply once more. Never add `expectedVersion` to source and never loop retries.
 
+### Unexplained node drift after apply
+
+Object settings preserve omitted live keys, but list-valued settings such as conditions, predicates, entities, steps, and rules can be compared as whole values after the server adds defaults inside an element. If plan reports an unnamed node change after a clean apply, run `toloka import` into a scratch directory outside the source root, compare that node with source, and declare only the materialized key needed for convergence. Delete the scratch directory afterward and never re-apply blindly.
+
 ### Server 400 after a clean validate
 
-Read the returned path and reason. Check connection endpoints, duplicate or unknown IDs preserved from imported source, field references, and any accidentally authored layout. Fix source, rerun `toloka validate`, plan, and apply. Do not bypass reconciliation with a raw API call.
+A new pipeline is skipped by `toloka validate` until it exists remotely, and apply can create its dataset and fields before pipeline import returns a 400. Fix the reported path or reason, then run plan again. If only the pipeline addition remains, continue from that diff; do not recreate or rename resources already created. Check connection endpoints, duplicate or unknown imported IDs, field references, and accidentally authored layout. Never bypass reconciliation with a raw API call.
 
 ## Use the shipped example
 

package/skills/toloka-report-issue/references/report-template.md

@@ -26,7 +26,7 @@ The CLI exits 1 with `Potato API request failed with status 500`. The same comma
 
 ## Environment
 
-- toloka CLI 0.1.0-preview.5 (`toloka --version`), Bun 1.4.0, macOS 15
+- toloka CLI 0.1.0-preview.7 (`toloka --version`), Bun 1.4.0, macOS 15
 - Platform: https://platform.toloka.ai
 
 ## Redactions

package/src/checks/ast.ts

@@ -0,0 +1,32 @@
+import type { JSXAttribute } from "oxc-parser";
+import { parseSync } from "oxc-parser";
+
+// Sources are parsed with the same wrapping buildCompositeSource (task-ui-typecheck.ts) injects — if that
+// wrapping changes, change parseProgram's callers with it.
+export const parseProgram = (filename: string, source: string, lang: "ts" | "tsx") => {
+  const result = parseSync(filename, source, { lang, preserveParens: false });
+
+  return result.errors.some((error) => error.severity === "Error") ? null : result.program;
+};
+
+export const resolveAttributeString = (attribute: JSXAttribute | undefined): string | null => {
+  const value = attribute?.value;
+
+  if (!value) return null;
+
+  if (value.type === "Literal") return typeof value.value === "string" ? value.value : null;
+
+  if (value.type === "JSXExpressionContainer") {
+    const expression = value.expression;
+
+    if (expression.type === "Literal" && typeof expression.value === "string") {
+      return expression.value;
+    }
+
+    if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) {
+      return expression.quasis[0]?.value.cooked ?? null;
+    }
+  }
+
+  return null;
+};

package/src/checks/index.ts

@@ -0,0 +1,14 @@
+export { findPostprocessKeyCollisions } from "./postprocess-collisions";
+export {
+  createBundledTaskUiTypechecker,
+  createTaskUiTypechecker,
+  taskUiDeclarationSnapshot,
+} from "./task-ui-typecheck";
+export type {
+  TaskUiBlockKey,
+  TaskUiDeclarationSource,
+  TaskUiDiagnostic,
+  TaskUiDiagnosticsReport,
+  TaskUiSource,
+  TaskUiTypechecker,
+} from "./task-ui-typecheck";

package/src/checks/postprocess-collisions.ts

@@ -0,0 +1,145 @@
+import type { BlockStatement, Expression, JSXAttribute, ObjectExpression } from "oxc-parser";
+import { Visitor } from "oxc-parser";
+
+import { parseProgram, resolveAttributeString } from "./ast";
+import type { TaskUiDiagnostic, TaskUiSource } from "./task-ui-typecheck";
+
+// Collisions in conditional return branches are errors too: a submission whose data reaches the
+// branch still dies at getData().
+export const findPostprocessKeyCollisions = (
+  ui: Pick<TaskUiSource, "code" | "postprocess">,
+): TaskUiDiagnostic[] => {
+  const returnedKeys = extractPostprocessReturnedKeys(ui.postprocess);
+  if (!returnedKeys || returnedKeys.size === 0) return [];
+  const bindings = extractFieldPathBindings(ui.code);
+  if (!bindings || bindings.size === 0) return [];
+
+  return [...bindings]
+    .filter(([key]) => returnedKeys.has(key))
+    .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+    .map(([key, path]) => {
+      const binding =
+        path === key
+          ? `path="${path}"`
+          : `path="${path}" — a dotted path binds its top-level key "${key}"`;
+      return {
+        severity: "error",
+        text:
+          `Postprocess returns the key "${key}", but a Field component is bound to it (${binding}). ` +
+          `Every submission of this interface fails at runtime with: Postprocess cannot write key '${key}' because a component is bound to it. ` +
+          `Fix: bind the Field to a raw key (e.g. path="raw_${key}") and derive "${key}" in postprocess, or remove "${key}" from the postprocess return.`,
+      };
+    });
+};
+
+const extractFieldPathBindings = (code: string): Map<string, string> | null => {
+  const program = parseProgram("code.tsx", `(\n${code}\n)`, "tsx");
+  if (!program) return null;
+  const bindings = new Map<string, string>();
+  const visitor = new Visitor({
+    JSXOpeningElement(node) {
+      let name = node.name;
+      while (name.type === "JSXMemberExpression") name = name.object;
+      if (name.type !== "JSXIdentifier" || name.name !== "Field") return;
+      const pathAttribute = node.attributes.find(
+        (attribute): attribute is JSXAttribute =>
+          attribute.type === "JSXAttribute" &&
+          attribute.name.type === "JSXIdentifier" &&
+          attribute.name.name === "path",
+      );
+      const path = resolveAttributeString(pathAttribute);
+      if (!path) return;
+      const key = path.split(/[.[]/u)[0];
+      if (key && !bindings.has(key)) bindings.set(key, path);
+    },
+  });
+  visitor.visit(program);
+  return bindings;
+};
+
+const extractPostprocessReturnedKeys = (postprocess: string): Set<string> | null => {
+  const program = parseProgram("postprocess.ts", `(() => {\n${postprocess}\n})`, "ts");
+  if (!program) return null;
+  const statement = program.body.length === 1 ? program.body[0] : undefined;
+  // postprocess text can escape the wrapper braces yet still parse — `}) , (() => {` turns the
+  // expression into a SequenceExpression — so only the intact wrapper shape is analyzable
+  if (
+    statement?.type !== "ExpressionStatement" ||
+    statement.expression.type !== "ArrowFunctionExpression" ||
+    statement.expression.body.type !== "BlockStatement"
+  ) {
+    return null;
+  }
+  const keys = new Set<string>();
+  for (const returned of collectOwnReturnArguments(statement.expression.body)) {
+    collectObjectLiteralKeys(returned, keys);
+  }
+  return keys;
+};
+
+const functionNodeTypes = new Set([
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "FunctionDeclaration",
+]);
+
+const collectOwnReturnArguments = (body: BlockStatement): Expression[] => {
+  const returned: Expression[] = [];
+  const visit = (node: unknown): void => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    const candidate = node as { type?: unknown } & Record<string, unknown>;
+    if (typeof candidate.type === "string") {
+      if (functionNodeTypes.has(candidate.type)) return;
+      if (candidate.type === "ReturnStatement" && candidate.argument) {
+        returned.push(candidate.argument as Expression);
+      }
+    }
+    for (const value of Object.values(candidate)) visit(value);
+  };
+  visit(body.body);
+  return returned;
+};
+
+const collectObjectLiteralKeys = (expression: Expression, keys: Set<string>): void => {
+  if (expression.type === "ObjectExpression") {
+    collectPropertyKeys(expression, keys);
+  } else if (expression.type === "ConditionalExpression") {
+    collectObjectLiteralKeys(expression.consequent, keys);
+    collectObjectLiteralKeys(expression.alternate, keys);
+  } else if (expression.type === "LogicalExpression") {
+    collectObjectLiteralKeys(expression.left, keys);
+    collectObjectLiteralKeys(expression.right, keys);
+  } else if (expression.type === "SequenceExpression") {
+    const last = expression.expressions.at(-1);
+    if (last) collectObjectLiteralKeys(last, keys);
+  } else if (
+    expression.type === "TSAsExpression" ||
+    expression.type === "TSSatisfiesExpression" ||
+    expression.type === "TSNonNullExpression" ||
+    expression.type === "TSTypeAssertion"
+  ) {
+    collectObjectLiteralKeys(expression.expression, keys);
+  }
+};
+
+const collectPropertyKeys = (objectExpression: ObjectExpression, keys: Set<string>): void => {
+  for (const property of objectExpression.properties) {
+    if (property.type === "SpreadElement") {
+      if (property.argument.type === "ObjectExpression")
+        collectPropertyKeys(property.argument, keys);
+      continue;
+    }
+    if (!property.computed && property.key.type === "Identifier") {
+      keys.add(property.key.name);
+    } else if (
+      property.key.type === "Literal" &&
+      (typeof property.key.value === "string" || typeof property.key.value === "number")
+    ) {
+      keys.add(String(property.key.value));
+    }
+  }
+};