diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.h
index de1cc03f9..227f3a376 100644
--- a/internal/cbm/cbm.h
+++ b/internal/cbm/cbm.h
@@ -399,7 +399,9 @@ typedef struct {
// C++ operator). Never fall back to textual resolution.
bool callee_is_locally_bound; // bare call foo() whose callee identifier is bound as a
// parameter of an enclosing function, so it cannot be the
- // module-level foo. Python only today. Read by the
+ // module-level foo. Python: parameters. JS/TS/TSX: also a
+ // local that names no definition (const f = wrap(...),
+ // an array-pattern element). Read by the
// weak-local-binding guard. Default false.
bool receiver_is_amd_dependency; // JS/TS member call x.foo() whose receiver root x is a
// parameter the factory of an enclosing AMD
diff --git a/internal/cbm/extract_unified.c b/internal/cbm/extract_unified.c
index 29457b3cf..db32c5c6e 100644
--- a/internal/cbm/extract_unified.c
+++ b/internal/cbm/extract_unified.c
@@ -3026,6 +3026,7 @@ void cbm_extract_unified(CBMExtractCtx *ctx) {
state.py_param_stack_count = 0;
state.py_param_tracking_failed = false;
state.usage_start_index = ctx->result->usages.count;
+ state.call_start_index = ctx->result->calls.count;
state.root_lexical_scope_id = add_lexical_scope(&state, ctx->root, CBM_LEXICAL_SCOPE_MODULE);
/* Base walk-state tuple (previously established by the first
* recompute_state call): module scope, nothing else active. */
diff --git a/internal/cbm/extract_unified.h b/internal/cbm/extract_unified.h
index e2690e59f..89675064c 100644
--- a/internal/cbm/extract_unified.h
+++ b/internal/cbm/extract_unified.h
@@ -124,6 +124,12 @@ typedef struct {
uint32_t active_start;
uint32_t active_end;
const char *name;
+ /* JS/TS only: a parameter, or a local this declaration names for a value
+ * that is no function it declares (`const save = useCallback(...)`,
+ * `const [open, setOpen] = useState()`). No definition in the project
+ * carries that name through this binding, so a bare call of it cannot be
+ * placed by short name. Sits in the struct's tail padding. */
+ bool names_no_definition;
} CBMLexicalBinding;
typedef enum {
@@ -189,6 +195,7 @@ typedef struct {
int lexical_binding_capacity;
int lexical_binding_count;
int usage_start_index;
+ int call_start_index;
bool lexical_binding_tracking_failed;
CBMPythonDirective *python_directives;
CBMPythonDirective inline_python_directives[INLINE_PYTHON_DIRECTIVES];
diff --git a/internal/cbm/extract_usages.c b/internal/cbm/extract_usages.c
index ace6c76ef..d825d6c41 100644
--- a/internal/cbm/extract_usages.c
+++ b/internal/cbm/extract_usages.c
@@ -2126,6 +2126,63 @@ static bool js_var_binding(TSNode node) {
return false;
}
+static bool js_family_language(CBMLanguage language) {
+ return language == CBM_LANG_JAVASCRIPT || language == CBM_LANG_TYPESCRIPT ||
+ language == CBM_LANG_TSX || language == CBM_LANG_ARKTS;
+}
+
+/* Does a JS/TS declarator's initializer declare a function or class under the
+ * declarator's name? Those are graph definitions (`const save = () => {}`), so
+ * a call of the name has a real target. Type-only wrappers are looked through. */
+static bool js_value_declares_callable(TSNode value) {
+ for (int hops = 0; hops < CBM_SZ_8 && !ts_node_is_null(value); hops++) {
+ const char *kind = ts_node_type(value);
+ bool wrapper =
+ strcmp(kind, "parenthesized_expression") == 0 || strcmp(kind, "as_expression") == 0 ||
+ strcmp(kind, "satisfies_expression") == 0 || strcmp(kind, "non_null_expression") == 0;
+ if (!wrapper) {
+ return strcmp(kind, "arrow_function") == 0 ||
+ strcmp(kind, "function_expression") == 0 || strcmp(kind, "function") == 0 ||
+ strcmp(kind, "generator_function") == 0 || strcmp(kind, "class") == 0;
+ }
+ value = ts_node_named_child(value, 0);
+ }
+ return false;
+}
+
+/* True when a JS/TS binding names no definition of the project: a parameter,
+ * a declarator whose initializer is not a function or class
+ * (`const save = useCallback(...)`), or an array-pattern element
+ * (`const [open, setOpen] = useState()`). The declaration chose the name, so a
+ * project function that merely shares it is unrelated.
+ *
+ * Deliberately NOT flagged: a nested function declaration and a function-valued
+ * declarator (real definitions), a renamed object-pattern value and a
+ * declarator without initializer (assigned later, unknown). A shorthand
+ * object-pattern name (`const { removeItem } = useStore()`, a destructured
+ * prop) is no binding occurrence for this walk at all, so it is never flagged
+ * either; in a declarator that name is a member some definition does declare. */
+static bool js_binding_names_no_definition(TSNode node, bool parameter) {
+ if (parameter) {
+ return true;
+ }
+ TSNode parent = ts_node_parent(node);
+ if (ts_node_is_null(parent)) {
+ return false;
+ }
+ const char *kind = ts_node_type(parent);
+ if (strcmp(kind, "array_pattern") == 0) {
+ return true;
+ }
+ if (strcmp(kind, "variable_declarator") != 0) {
+ return false;
+ }
+ TSNode name = ts_node_child_by_field_name(parent, TS_FIELD("name"));
+ TSNode value = ts_node_child_by_field_name(parent, TS_FIELD("value"));
+ return !ts_node_is_null(name) && ts_node_eq(name, node) && !ts_node_is_null(value) &&
+ !js_value_declares_callable(value);
+}
+
static bool import_kind_matches(TSNode node, const CBMLangSpec *spec) {
return (spec->import_node_types && cbm_kind_in_set(node, spec->import_node_types)) ||
(spec->import_from_types && cbm_kind_in_set(node, spec->import_from_types));
@@ -2412,8 +2469,7 @@ static void record_lexical_binding(CBMExtractCtx *ctx, WalkState *state, TSNode
} else if (ctx->language == CBM_LANG_POWERSHELL) {
scope_id = lexical_ancestor_of_kind(state, current_id, true, false);
whole_scope = true;
- } else if (ctx->language == CBM_LANG_JAVASCRIPT || ctx->language == CBM_LANG_TYPESCRIPT ||
- ctx->language == CBM_LANG_TSX || ctx->language == CBM_LANG_ARKTS) {
+ } else if (js_family_language(ctx->language)) {
bool is_var = js_var_binding(node);
scope_id = lexical_ancestor_of_kind(state, current_id, is_var, !is_var);
if (scope_id == 0) {
@@ -2449,6 +2505,9 @@ static void record_lexical_binding(CBMExtractCtx *ctx, WalkState *state, TSNode
* signature/body languages extend the scope after parameters are seen. */
binding->active_end = 0;
binding->name = name;
+ binding->names_no_definition = !import_binding && ts_node_is_null(function_declaration) &&
+ js_family_language(ctx->language) &&
+ js_binding_names_no_definition(node, parameter);
}
static int compare_lexical_bindings(const void *left_ptr, const void *right_ptr) {
@@ -2531,6 +2590,84 @@ static const CBMLexicalScope *lexical_binding_scope_for_usage(const WalkState *s
return NULL;
}
+/* Innermost lexical scope holding `position`, 0 when none does. Scopes are
+ * appended as the walk opens them, so their start bytes never decrease: the
+ * last one starting at or before the position is the innermost candidate, and
+ * each one that already closed hands over to its parent. */
+static uint32_t lexical_scope_at(const WalkState *state, uint32_t position) {
+ int low = 0;
+ int high = state->lexical_scope_count;
+ while (low < high) {
+ int middle = low + (high - low) / PAIR_LEN;
+ if (state->lexical_scopes[middle].start_byte <= position) {
+ low = middle + 1;
+ } else {
+ high = middle;
+ }
+ }
+ uint32_t scope_id = (uint32_t)low;
+ int remaining = state->lexical_scope_count;
+ while (scope_id != 0 && remaining-- > 0) {
+ const CBMLexicalScope *scope = usage_lexical_scope(state, scope_id);
+ if (!scope || position < scope->end_byte) {
+ break;
+ }
+ scope_id = scope->parent_id;
+ }
+ return scope_id;
+}
+
+/* JS/TS: flag every bare call `name()` whose nearest binding of `name` is a
+ * local one that names no definition (js_binding_names_no_definition). The
+ * resolver then refuses a weak short-name match for it, as it does for a
+ * Python parameter: `const submit = useCallback(...)` followed by `submit()`
+ * must not become a CALLS edge to an unrelated `submit` in a file the caller
+ * never imports.
+ *
+ * Runs after the walk because let/const/var bind their whole scope: a handler
+ * may call a local that is declared further down. A scope that binds the name
+ * more than once is flagged only when every active binding agrees, so a real
+ * nested definition always keeps its edge. On an allocation failure nothing is
+ * flagged, which costs a suppression and never a true edge. */
+static void flag_js_locally_bound_callees(CBMExtractCtx *ctx, const WalkState *state) {
+ for (int i = state->call_start_index; i < ctx->result->calls.count; i++) {
+ CBMCall *call = &ctx->result->calls.items[i];
+ const char *name = call->callee_name;
+ if (!name || !name[0] || strchr(name, '.') || call->site_end_byte == 0) {
+ continue;
+ }
+ uint32_t scope_id = lexical_scope_at(state, call->site_start_byte);
+ int remaining = state->lexical_scope_count;
+ while (scope_id != 0 && remaining-- > 0) {
+ const CBMLexicalScope *scope = usage_lexical_scope(state, scope_id);
+ if (!scope) {
+ break;
+ }
+ bool bound = false;
+ bool no_definition = true;
+ for (int b = lexical_binding_lower_bound(state, scope_id, name);
+ b < state->lexical_binding_count; b++) {
+ const CBMLexicalBinding *binding = &state->lexical_bindings[b];
+ if (binding->scope_id != scope_id || strcmp(binding->name, name) != 0) {
+ break;
+ }
+ uint32_t active_end = binding->active_end ? binding->active_end : scope->end_byte;
+ if (binding->active_start <= call->site_start_byte &&
+ call->site_start_byte < active_end) {
+ bound = true;
+ no_definition = no_definition && binding->names_no_definition;
+ }
+ }
+ if (bound) {
+ call->callee_is_locally_bound =
+ no_definition && scope->kind != CBM_LEXICAL_SCOPE_MODULE;
+ break;
+ }
+ scope_id = scope->lookup_parent_id;
+ }
+ }
+}
+
void cbm_finalize_lexical_usages(CBMExtractCtx *ctx, WalkState *state) {
if (!ctx || !state) {
return;
@@ -2539,6 +2676,9 @@ void cbm_finalize_lexical_usages(CBMExtractCtx *ctx, WalkState *state) {
qsort(state->lexical_bindings, (size_t)state->lexical_binding_count,
sizeof(*state->lexical_bindings), compare_lexical_bindings);
}
+ if (js_family_language(ctx->language) && !state->lexical_binding_tracking_failed) {
+ flag_js_locally_bound_callees(ctx, state);
+ }
for (int i = state->usage_start_index; i < ctx->result->usages.count; i++) {
CBMUsage *usage = &ctx->result->usages.items[i];
if (!usage->ref_name || !usage->ref_name[0]) {
diff --git a/src/pipeline/pass_calls.c b/src/pipeline/pass_calls.c
index 4430e9d44..07ac2d360 100644
--- a/src/pipeline/pass_calls.c
+++ b/src/pipeline/pass_calls.c
@@ -1346,10 +1346,10 @@ static int resolve_single_call(cbm_pipeline_ctx_t *ctx, CBMCall *call, const CBM
lang == CBM_LANG_SWIFT;
/* Bare-call local-binding suppression. A member call has a receiver the
* guard above can reason about; a bare `run()` has none, so that guard
- * cannot see this class at all. Python-only today because the extraction
- * flag is set only for Python — this gate MUST match pass_parallel.c's
- * exactly, for the same divergence reason noted above. */
- bool suppress_weak_local_binding = lang == CBM_LANG_PYTHON;
+ * cannot see this class at all. The language set is the one the extractor
+ * sets the flag for, and lives in the helper so that this gate and
+ * pass_parallel.c's cannot diverge. */
+ bool suppress_weak_local_binding = cbm_weak_local_binding_guard_lang(lang);
/* The member guard's one exemption (Python, self/cls-rooted receiver,
* unique_name, not a builtin type's method) — see
* cbm_weak_member_unique_name_exempt. MUST match pass_parallel.c exactly. */
diff --git a/src/pipeline/pass_parallel.c b/src/pipeline/pass_parallel.c
index 71b5b684f..91dcfb8f4 100644
--- a/src/pipeline/pass_parallel.c
+++ b/src/pipeline/pass_parallel.c
@@ -3558,8 +3558,8 @@ static void resolve_file_calls(resolve_ctx_t *rc, resolve_worker_state_t *ws, CB
/* Swift initializer calls only — see pass_calls.c */
lang == CBM_LANG_SWIFT;
/* Bare-call local-binding suppression — see the note in pass_calls.c.
- * This gate MUST stay identical to the one there. */
- bool suppress_weak_local_binding = lang == CBM_LANG_PYTHON;
+ * The shared helper keeps this gate identical to the one there. */
+ bool suppress_weak_local_binding = cbm_weak_local_binding_guard_lang(lang);
/* The member guard's one exemption — MUST match pass_calls.c exactly. */
/* #1355: same guard as pass_calls.c, and joined to drop_plain_call for
* the same reason — a `continue` here would also skip route/HTTP/CONFIG
diff --git a/src/pipeline/pipeline.h b/src/pipeline/pipeline.h
index 26bf59c0b..a7dfbca5b 100644
--- a/src/pipeline/pipeline.h
+++ b/src/pipeline/pipeline.h
@@ -486,12 +486,16 @@ bool cbm_weak_member_unique_name_exempt(bool is_python, bool receiver_is_self_at
* from a weak short-name strategy — so the edge is fabricated by construction
* (`def f(run): run()` must not bind an unrelated `SatoriLive.run`). Shares the
* member guard's drop-list, so lsp_* / import / same-module matches are kept.
- * Deliberately keyed on the SCOPE FACT, not on the callee's spelling. The
- * language set lives at the call sites (pass_calls.c / pass_parallel.c) and must
- * be identical in both, or the sequential and parallel resolvers diverge.
- * Pure; unit-tested in test_registry.c. */
+ * Deliberately keyed on the SCOPE FACT, not on the callee's spelling. Both
+ * call sites (pass_calls.c / pass_parallel.c) take `enabled` from
+ * cbm_weak_local_binding_guard_lang, so the sequential and parallel resolvers
+ * cannot diverge. Pure; unit-tested in test_registry.c. */
bool cbm_suppress_weak_local_binding_call(bool enabled, bool callee_is_locally_bound,
const char *strategy);
+/* The languages whose extractor sets CBMCall.callee_is_locally_bound: Python
+ * (a parameter) and JS/TS/TSX/ArkTS (a parameter, or a local that names no
+ * definition). Pure; unit-tested in test_registry.c. */
+bool cbm_weak_local_binding_guard_lang(CBMLanguage lang);
/* #1355: drop a project-wide same-name guess (suffix_match / unique_name /
* field_type_hint / fuzzy) for a BARE call whose name the calling file binds to
* a NON-RELATIVE (package) import that resolved to nothing in the graph —
diff --git a/src/pipeline/registry.c b/src/pipeline/registry.c
index 73c2a4148..5ca327dab 100644
--- a/src/pipeline/registry.c
+++ b/src/pipeline/registry.c
@@ -775,6 +775,15 @@ bool cbm_weak_member_unique_name_exempt(bool is_python, bool receiver_is_self_at
* same reason as the member guard: the two call sites in pass_calls.c and
* pass_parallel.c MUST enumerate the identical language set, or the sequential
* and parallel resolvers diverge. Pure; unit-tested in test_registry.c. */
+/* The languages whose extractor sets CBMCall.callee_is_locally_bound: Python
+ * for a parameter (#1912), and the JS family for a parameter or a local that
+ * names no definition (`const submit = useCallback(...)`, an array-pattern
+ * element; #1355). One list for both resolvers. */
+bool cbm_weak_local_binding_guard_lang(CBMLanguage lang) {
+ return lang == CBM_LANG_PYTHON || lang == CBM_LANG_JAVASCRIPT || lang == CBM_LANG_TYPESCRIPT ||
+ lang == CBM_LANG_TSX || lang == CBM_LANG_ARKTS;
+}
+
bool cbm_suppress_weak_local_binding_call(bool enabled, bool callee_is_locally_bound,
const char *strategy) {
if (!enabled || !callee_is_locally_bound) {
diff --git a/tests/test_extraction.c b/tests/test_extraction.c
index 041c6db51..2abcbc334 100644
--- a/tests/test_extraction.c
+++ b/tests/test_extraction.c
@@ -9930,6 +9930,105 @@ TEST(extract_python_bare_call_flags_locally_bound_callee) {
PASS();
}
+/* #1355: the JS/TS twin of the Python flag above. A bare call is flagged when
+ * its nearest binding is a local that names no definition of the project: a
+ * parameter, a declarator whose initializer is not a function
+ * (`const submitForm = useCallback(...)`), an array-pattern element. Pins both
+ * directions, and the whole-scope rule: `lateBound` is declared after the
+ * handler that calls it. A shorthand object-pattern name is not a binding
+ * occurrence of the walk, so `removeItem` stays unflagged. */
+TEST(extract_tsx_bare_call_flags_locally_bound_callee) {
+ CBMFileResult *r = extract("import { useCallback, useState } from 'react';\n"
+ "import { imported } from './lib';\n"
+ "import { useStore } from './useStore';\n"
+ "\n"
+ "const moduleConst = wrap(() => 1);\n"
+ "\n"
+ "export function Panel(props: Props, onParam: () => void) {\n"
+ " const [open, setOpen] = useState(false);\n"
+ " const { removeItem } = useStore();\n"
+ " const submitForm = useCallback(async (v: string) => v, []);\n"
+ " const typedLocal = pick() as () => void;\n"
+ " const plainArrow = () => 1;\n"
+ " const castArrow = ((x: number) => x) as Fn;\n"
+ " function nestedDecl() { return 2; }\n"
+ " const go = () => {\n"
+ " submitForm('x');\n"
+ " lateBound();\n"
+ " setOpen(!open);\n"
+ " onParam();\n"
+ " typedLocal();\n"
+ " removeItem(1);\n"
+ " plainArrow();\n"
+ " castArrow(1);\n"
+ " nestedDecl();\n"
+ " moduleLevel();\n"
+ " moduleConst();\n"
+ " imported();\n"
+ " };\n"
+ " const lateBound = useCallback(() => 0, []);\n"
+ " return ;\n"
+ "}\n"
+ "\n"
+ "export function sibling() {\n"
+ " return unboundHere();\n"
+ "}\n",
+ CBM_LANG_TSX, "t", "Panel.tsx");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+
+ struct {
+ const char *callee;
+ bool expect_bound;
+ int seen;
+ } cases[] = {
+ {"submitForm", true, 0}, /* const x = useCallback(...): the reported shape */
+ {"lateBound", true, 0}, /* same, declared after the caller (const TDZ scope) */
+ {"setOpen", true, 0}, /* array-pattern element */
+ {"onParam", true, 0}, /* parameter */
+ {"typedLocal", true, 0}, /* call result behind a type assertion */
+ {"removeItem", false, 0}, /* object-pattern key: names a member, keep guess */
+ {"plainArrow", false, 0}, /* arrow-valued const: a real definition */
+ {"castArrow", false, 0}, /* arrow behind parentheses and `as` */
+ {"nestedDecl", false, 0}, /* nested function declaration */
+ {"moduleLevel", false, 0}, /* unbound: the true cross-file edge */
+ {"moduleConst", false, 0}, /* module-scope binding, not a local */
+ {"imported", false, 0}, /* import binding */
+ {"unboundHere", false, 0}, /* unbound in a sibling function */
+ };
+ const int case_count = (int)(sizeof(cases) / sizeof(cases[0]));
+
+ for (int i = 0; i < r->calls.count; i++) {
+ const char *cn = r->calls.items[i].callee_name;
+ if (!cn) {
+ continue;
+ }
+ for (int c = 0; c < case_count; c++) {
+ if (strcmp(cn, cases[c].callee) != 0) {
+ continue;
+ }
+ cases[c].seen++;
+ if (r->calls.items[i].callee_is_locally_bound != cases[c].expect_bound) {
+ printf(" bare-call flag mismatch for %s(): got %d, expected %d\n", cases[c].callee,
+ r->calls.items[i].callee_is_locally_bound ? 1 : 0,
+ cases[c].expect_bound ? 1 : 0);
+ }
+ ASSERT_EQ(r->calls.items[i].callee_is_locally_bound, cases[c].expect_bound);
+ }
+ }
+ /* Each shape must appear exactly once, so a missed extraction cannot let the
+ * loop above pass vacuously. */
+ for (int c = 0; c < case_count; c++) {
+ if (cases[c].seen != 1) {
+ printf(" bare call %s() extracted %d times, expected 1\n", cases[c].callee,
+ cases[c].seen);
+ }
+ ASSERT_EQ(cases[c].seen, 1);
+ }
+ cbm_free_result(r);
+ PASS();
+}
+
TEST(extract_go_selector_call_flags_is_method) {
/* Go selector calls are flagged so the weak-match guard can fire when the
* Go LSP cannot type the receiver; bare calls stay unflagged. */
@@ -15690,6 +15789,7 @@ SUITE(extraction) {
RUN_TEST(extract_flag_exempt_method_call_not_flagged_is_method);
RUN_TEST(extract_python_member_call_flags_is_method);
RUN_TEST(extract_python_bare_call_flags_locally_bound_callee);
+ RUN_TEST(extract_tsx_bare_call_flags_locally_bound_callee);
RUN_TEST(extract_python_bare_call_flag_is_depth_independent);
RUN_TEST(extract_go_selector_call_flags_is_method);
RUN_TEST(extract_go_method_receiver_qualified_qn);
diff --git a/tests/test_pipeline.c b/tests/test_pipeline.c
index ff4e6d0d6..0e4f43136 100644
--- a/tests/test_pipeline.c
+++ b/tests/test_pipeline.c
@@ -15249,6 +15249,161 @@ TEST(pipeline_external_import_shadow_not_bound_to_local_homonym_issue1355) {
PASS();
}
+/* #1355: a bare call whose callee the calling function binds locally to a
+ * value that is no definition (`const submitForm = useCallback(...)`, a
+ * useState setter, a callback parameter) must not bind by short name to an unrelated
+ * function that merely shares the name, in a file the caller never imports.
+ * `pad_files` filler modules push the run over MIN_FILES_FOR_PARALLEL. */
+static void write_local_binding_shadow_fixture(const char *dir, int pad_files) {
+ /* The lone project functions named submitForm / setOpen / onDone. Nothing
+ * imports this file. */
+ write_temp_file(dir, "src/Elsewhere.tsx",
+ "export function submitForm(v: string) {\n"
+ " return v;\n"
+ "}\n"
+ "export function setOpen(v: boolean) {\n"
+ " return v;\n"
+ "}\n"
+ "export function onDone() {\n"
+ " return 0;\n"
+ "}\n");
+ write_temp_file(dir, "src/Caller.tsx",
+ "import { useCallback, useState } from 'react';\n"
+ "\n"
+ "export function Caller() {\n"
+ " const [open, setOpen] = useState(false);\n"
+ " const submitForm = useCallback(async (v: string) => v.length, []);\n"
+ " const localStep = () => 1;\n"
+ " const go = () => {\n"
+ " void submitForm('x');\n"
+ " setOpen(!open);\n"
+ " localStep();\n"
+ " };\n"
+ " return ;\n"
+ "}\n"
+ "\n"
+ "export function useRunner(onDone: () => void) {\n"
+ " const finish = () => {\n"
+ " onDone();\n"
+ " };\n"
+ " return finish;\n"
+ "}\n");
+ /* No binding of the name at all: nothing in the caller's source contradicts
+ * the guess, so the pre-existing fallback keeps its edge. */
+ write_temp_file(dir, "src/NoBinding.tsx",
+ "export function callsUnbound() {\n"
+ " return submitForm('y');\n"
+ "}\n");
+ /* An object-pattern key names a member that a definition does declare, so
+ * its name guess is kept. */
+ write_temp_file(dir, "src/useStore.ts",
+ "export function useStore() {\n"
+ " return { removeItem: (id: number) => id };\n"
+ "}\n");
+ write_temp_file(dir, "src/ListPage.tsx",
+ "import { useStore } from './useStore';\n"
+ "\n"
+ "export function ListPage() {\n"
+ " const { removeItem } = useStore();\n"
+ " return