{"instance_id": "fuse-dev/circuit_001", "task": "circuit_001", "status": "study task: run in the preliminary Gemma 4 study (suites sealed 6 November 2026)", "source": "adapted from a SlopCodeBench task family (problem repository commit 9cd9ca3a); rewritten for FUSE", "license": "Apache-2.0", "requirement_A": "# Current work: vector-capable two-valued circuits\n\nExtend the supplied scalar evaluator to support bit vectors while preserving scalar behavior. Only 0 and 1 are logical values. No new circuit file formats or public format-selection options are in scope.\n\nThe command is `python -m fusecircuit PATH --inputs JSON_OBJECT`. On success exit 0 and print exactly one JSON object mapping output names to nonempty bitstrings; output key order is irrelevant. On invalid input exit nonzero, print an explanation to stderr, and print no result to stdout. `--help` must work. Keep this interface; internal structure is unconstrained.\n\nSource syntax (one declaration per line):\n```\nINPUT a 4\nINPUT enable 1\nn = AND(a,enable)\nresult = NOT(n)\nOUTPUT result\n```\nBlank lines, surrounding whitespace, and `#` comments (whole-line or trailing) are ignored. Names match `[A-Za-z_][A-Za-z0-9_]*`, are case-sensitive, and share one namespace across inputs and gates. Input widths are positive decimal integers without leading zeros. Declarations can be in any order. Operands are names or nonempty literal bitstrings. `NOT` and `BUF` take exactly one operand; `AND`, `OR`, `XOR`, `NAND`, `NOR`, and `XNOR` take exactly two. Operators are uppercase and bitwise, following ordinary Boolean truth tables. An output refers to a declared input or gate. Multiple distinct outputs are allowed; at least one is required.\n\nEach declared input must have exactly one supplied string value of exactly its declared width. Reject undeclared supplied inputs, missing inputs, non-string values, nonbinary characters, and width mismatches. Width-one operands broadcast to the other operand's width; unequal widths greater than one are invalid. Unary results retain operand width. Literals follow the same width/broadcast rules as signals.\n\nReject duplicate input/gate names, duplicate outputs, unsupported operators, wrong arity, malformed syntax, undefined signals, and cycles. Validate all gates, including unused ones. Existing scalar invocations remain valid. Do not add three-valued behavior or additional circuit formats.\n", "requirement_B1": "# Add unknown logical values\n\nPreserve the entire A contract. Allow uppercase X in every input bitstring and source literal alongside 0 and 1, without requiring a flag. A declared signal named X remains valid and takes priority over interpreting an operand X as a literal. An unbound operand X denotes the unknown literal. Lowercase x in bitstrings is invalid (it can still be an ordinary signal name). Width rules remain unchanged. Outputs are strings over 0,1,X.\n\nBUF returns its input. NOT maps 0 to 1, 1 to 0, and X to X. AND returns 0 if either argument is 0, 1 if both are 1, otherwise X. OR returns 1 if either argument is 1, 0 if both are 0, otherwise X. XOR returns X if either argument is X, otherwise ordinary XOR. NAND, NOR, XNOR apply NOT to AND, OR, XOR respectively. Apply these rules independently to every vector position after scalar broadcasting.\n\nReject invalid characters, arities, widths, and all A validation errors. The existing command and source syntax remain available. JSON/BENCH circuit formats are not required. JSON transport of --inputs and output is already part of A, independent of circuit formats.\n", "requirement_B2": "# Add JSON and BENCH circuit input\n\nPreserve the entire A contract. Add `--format source|json|bench`, defaulting to source. Explicit source and omitted format must behave identically. Unknown formats must fail. This does not add X values.\n\nJSON circuits contain exactly the keys `inputs`, `gates`, `outputs`. Inputs is an object from valid names to positive integer widths (booleans are invalid widths). Gates is an array of objects with exactly `name`, `op`, `args`; name/op are strings and args is an array of operand strings. Outputs is a nonempty array of signal-name strings. Reject duplicate JSON keys at every nesting depth and reject extra/missing keys or incorrect types. Operators, literals, broadcast rules, ordering, namespace uniqueness, and validation follow A.\n```\n{\"inputs\":{\"a\":4,\"b\":1},\"gates\":[{\"name\":\"y\",\"op\":\"AND\",\"args\":[\"a\",\"b\"]}],\"outputs\":[\"y\"]}\n```\n\nBENCH is the following deliberately bounded dialect: `INPUT(name)` declares a width-one input; `OUTPUT(name)` selects an output; gates use A's `name = OP(operand,operand)` or unary syntax. Blank lines, whitespace, and # comments are accepted. Any declaration order is allowed. All signals/literals are scalar; reject vector literals. Support every A operator; no other BENCH dialect features are required. Reject duplicates, undefined signals, cycles, wrong arity, and malformed declarations. Supplied inputs must have width one.\n\nEquivalent circuits in all three formats must evaluate identically. Vector circuits can be represented in source or JSON. A+B2 must operate independently of three-valued logic.\n", "disclosure_B1": "A certain later requirement will allow a logical value X, meaning unknown, alongside 0 and 1. Circuits will use these values in scalar and vector inputs and literals, and every existing operator will obey three-valued logic. This functionality must remain deferred during the current phase.\n", "disclosure_B2": "A certain later requirement will accept circuits described in JSON and BENCH as well as the existing source format. Equivalent descriptions must give the same logical outputs and validation behavior, while existing source invocations remain compatible. This functionality must remain deferred during the current phase.\n", "scope_boundary": "B1:\n allowed_preparation: [generic value representation, localized existing operators, cohesive evaluation boundary]\n forbidden_behavior: [accepting X inputs or literals, working X truth tables, public three-valued mode]\n forbidden_breadcrumbs: [explicit unknown-value future plans, future-specific TODOs or tests]\n ambiguous: [unused generic semantic extension hooks]\nB2:\n allowed_preparation: [source parser separation, consistent internal representation]\n forbidden_behavior: [JSON circuit parser, BENCH circuit parser, public format selector]\n forbidden_breadcrumbs: [explicit future format plans, future-specific TODOs or tests]\n ambiguous: [unused generic parser registration]\nreview: Ambiguous properties and all negative automated screens require blinded manual adjudication.\n", "starter_files": [{"path": ".gitignore", "content": "__pycache__/\n*.pyc\n"}, {"path": "README.md", "content": "# Circuit evaluator\n\nRun `python -m fusecircuit path.txt --inputs '{\"a\":\"0\"}'`.\nThe source declares scalar inputs (`INPUT a 1`), logical gates (`n = NOT(a)`), and outputs (`OUTPUT n`). Supports NOT, BUF, AND, OR, XOR, NAND, NOR, XNOR.\n"}, {"path": "fusecircuit/__init__.py", "content": ""}, {"path": "fusecircuit/__main__.py", "content": "import argparse\nimport json\nimport re\nimport sys\nfrom pathlib import Path\nNAME = r\"[A-Za-z_][A-Za-z0-9_]*\"\nUNARY = {\"NOT\", \"BUF\"}\nBINARY = {\"AND\", \"OR\", \"XOR\", \"NAND\", \"NOR\", \"XNOR\"}\n\ndef execute(text, values):\n inputs, gates, outputs = {}, {}, []\n for raw in text.splitlines():\n line = raw.split(\"#\", 1)[0].strip()\n if not line:\n continue\n inp = re.fullmatch(rf\"INPUT\\s+({NAME})\\s+([1-9][0-9]*)\", line)\n out = re.fullmatch(rf\"OUTPUT\\s+({NAME})\", line)\n gate = re.fullmatch(rf\"({NAME})\\s*=\\s*([A-Z]+)\\((.*?)\\)\", line)\n if inp:\n name, width = inp.groups()\n if name in inputs or name in gates:\n raise ValueError(\"duplicate signal\")\n if int(width) != 1:\n raise ValueError(\"only scalar inputs supported\")\n inputs[name] = 1\n elif out:\n name = out[1]\n if name in outputs:\n raise ValueError(\"duplicate output\")\n outputs.append(name)\n elif gate:\n name, op, body = gate.groups()\n args = [arg.strip() for arg in body.split(\",\")]\n if name in inputs or name in gates or op not in UNARY | BINARY:\n raise ValueError(\"duplicate signal or unsupported operator\")\n if len(args) != (1 if op in UNARY else 2):\n raise ValueError(\"wrong arity\")\n if any(not re.fullmatch(rf\"(?:{NAME}|[01]+)\", a) for a in args):\n raise ValueError(\"invalid operand\")\n gates[name] = (op, args)\n else:\n raise ValueError(\"invalid source line\")\n if not outputs:\n raise ValueError(\"no outputs\")\n\n def scalar(op, a, b=None):\n if op == \"BUF\":\n return a\n if op == \"NOT\":\n return \"1\" if a == \"0\" else \"0\"\n if op in {\"AND\", \"NAND\"}:\n result = \"1\" if a == b == \"1\" else \"0\"\n elif op in {\"OR\", \"NOR\"}:\n result = \"1\" if \"1\" in (a, b) else \"0\"\n else:\n result = \"1\" if a != b else \"0\"\n return scalar(\"NOT\", result) if op in {\"NAND\", \"NOR\", \"XNOR\"} else result\n if not isinstance(values, dict) or set(values) != set(inputs):\n raise ValueError(\"provide exactly the declared inputs\")\n for name, width in inputs.items():\n value = values[name]\n if not isinstance(value, str) or not re.fullmatch(\"[01]+\", value) or len(value) != width:\n raise ValueError(\"invalid input value or width\")\n cache, active = dict(values), set()\n\n def resolve(name):\n if re.fullmatch(\"[01]+\", name):\n return name\n if name in cache:\n return cache[name]\n if name in active:\n raise ValueError(\"cycle\")\n if name not in gates:\n raise ValueError(\"undefined signal\")\n active.add(name)\n op, args = gates[name]\n operands = [resolve(arg) for arg in args]\n width = 1\n if any(len(value) not in (1, width) for value in operands):\n raise ValueError(\"incompatible widths\")\n expanded = [value * width if len(value) == 1 else value for value in operands]\n cache[name] = scalar(op, *[value for value in expanded])\n active.remove(name)\n return cache[name]\n\n for name in gates:\n resolve(name)\n return {name: resolve(name) for name in outputs}\n\n\ndef main():\n parser = argparse.ArgumentParser(description=\"Evaluate a circuit\")\n parser.add_argument(\"path\")\n parser.add_argument(\"--inputs\", required=True, help=\"JSON object of bitstrings\")\n args = parser.parse_args()\n try:\n print(json.dumps(execute(Path(args.path).read_text(), json.loads(args.inputs)), sort_keys=True))\n except (ValueError, OSError, RecursionError) as exc:\n print(str(exc), file=sys.stderr)\n return 2\n return 0\n\n\nif __name__ == \"__main__\":\n sys.exit(main())\n"}], "reference_A": [{"path": "fusecircuit/__init__.py", "content": "\"\"\"Reference implementation of the current circuit contract.\"\"\"\n"}, {"path": "fusecircuit/__main__.py", "content": "import argparse\nimport json\nimport re\nimport sys\nfrom pathlib import Path\n\n\nNAME = r\"[A-Za-z_][A-Za-z0-9_]*\"\nUNARY = {\"NOT\", \"BUF\"}\nBINARY = {\"AND\", \"OR\", \"XOR\", \"NAND\", \"NOR\", \"XNOR\"}\n\n\ndef parse_source(text):\n inputs, gates, outputs = {}, {}, []\n for raw in text.splitlines():\n line = raw.split(\"#\", 1)[0].strip()\n if not line:\n continue\n inp = re.fullmatch(rf\"INPUT\\s+({NAME})\\s+([1-9][0-9]*)\", line)\n out = re.fullmatch(rf\"OUTPUT\\s+({NAME})\", line)\n gate = re.fullmatch(rf\"({NAME})\\s*=\\s*([A-Z]+)\\((.*?)\\)\", line)\n if inp:\n name, width = inp.groups()\n if name in inputs or name in gates:\n raise ValueError(\"duplicate signal\")\n inputs[name] = int(width)\n elif out:\n name = out[1]\n if name in outputs:\n raise ValueError(\"duplicate output\")\n outputs.append(name)\n elif gate:\n name, op, body = gate.groups()\n args = [arg.strip() for arg in body.split(\",\")]\n if name in inputs or name in gates or op not in UNARY | BINARY:\n raise ValueError(\"duplicate signal or unsupported operator\")\n if len(args) != (1 if op in UNARY else 2):\n raise ValueError(\"wrong arity\")\n if any(not re.fullmatch(rf\"(?:{NAME}|[01]+)\", a) for a in args):\n raise ValueError(\"invalid operand\")\n gates[name] = (op, args)\n else:\n raise ValueError(\"invalid source line\")\n if not outputs:\n raise ValueError(\"no outputs\")\n return inputs, gates, outputs\n\n\ndef logic(op, a, b=None):\n if op == \"BUF\":\n return a\n if op == \"NOT\":\n return \"1\" if a == \"0\" else \"0\"\n if op in {\"AND\", \"NAND\"}:\n result = \"1\" if a == b == \"1\" else \"0\"\n elif op in {\"OR\", \"NOR\"}:\n result = \"1\" if \"1\" in (a, b) else \"0\"\n else:\n result = \"1\" if a != b else \"0\"\n return logic(\"NOT\", result) if op in {\"NAND\", \"NOR\", \"XNOR\"} else result\n\n\ndef evaluate(circuit, values):\n inputs, gates, outputs = circuit\n if not isinstance(values, dict) or set(values) != set(inputs):\n raise ValueError(\"provide exactly the declared inputs\")\n for name, width in inputs.items():\n value = values[name]\n if not isinstance(value, str) or not re.fullmatch(\"[01]+\", value) or len(value) != width:\n raise ValueError(\"invalid input value or width\")\n cache, active = dict(values), set()\n\n def resolve(name):\n if re.fullmatch(\"[01]+\", name):\n return name\n if name in cache:\n return cache[name]\n if name in active:\n raise ValueError(\"cycle\")\n if name not in gates:\n raise ValueError(\"undefined signal\")\n active.add(name)\n op, args = gates[name]\n operands = [resolve(arg) for arg in args]\n width = max(map(len, operands))\n if any(len(value) not in (1, width) for value in operands):\n raise ValueError(\"incompatible widths\")\n expanded = [value * width if len(value) == 1 else value for value in operands]\n cache[name] = \"\".join(logic(op, *bits) for bits in zip(*expanded))\n active.remove(name)\n return cache[name]\n\n for name in gates:\n resolve(name)\n return {name: resolve(name) for name in outputs}\n\n\ndef main():\n parser = argparse.ArgumentParser(description=\"Evaluate a circuit\")\n parser.add_argument(\"path\")\n parser.add_argument(\"--inputs\", required=True, help=\"JSON object of bitstrings\")\n args = parser.parse_args()\n try:\n circuit = parse_source(Path(args.path).read_text())\n print(json.dumps(evaluate(circuit, json.loads(args.inputs)), sort_keys=True))\n except (ValueError, OSError, RecursionError) as exc:\n print(str(exc), file=sys.stderr)\n return 2\n return 0\n\n\nif __name__ == \"__main__\":\n sys.exit(main())\n"}], "reference_B1": [{"path": "fusecircuit/__init__.py", "content": ""}, {"path": "fusecircuit/__main__.py", "content": "import argparse\nimport json\nimport re\nimport sys\nfrom pathlib import Path\n\n\nNAME = r\"[A-Za-z_][A-Za-z0-9_]*\"\nUNARY = {\"NOT\", \"BUF\"}\nBINARY = {\"AND\", \"OR\", \"XOR\", \"NAND\", \"NOR\", \"XNOR\"}\n\n\ndef parse_source(text):\n inputs, gates, outputs = {}, {}, []\n for raw in text.splitlines():\n line = raw.split(\"#\", 1)[0].strip()\n if not line:\n continue\n inp = re.fullmatch(rf\"INPUT\\s+({NAME})\\s+([1-9][0-9]*)\", line)\n out = re.fullmatch(rf\"OUTPUT\\s+({NAME})\", line)\n gate = re.fullmatch(rf\"({NAME})\\s*=\\s*([A-Z]+)\\((.*?)\\)\", line)\n if inp:\n name, width = inp.groups()\n if name in inputs or name in gates:\n raise ValueError(\"duplicate signal\")\n inputs[name] = int(width)\n elif out:\n name = out[1]\n if name in outputs:\n raise ValueError(\"duplicate output\")\n outputs.append(name)\n elif gate:\n name, op, body = gate.groups()\n args = [arg.strip() for arg in body.split(\",\")]\n if name in inputs or name in gates or op not in UNARY | BINARY:\n raise ValueError(\"duplicate signal or unsupported operator\")\n if len(args) != (1 if op in UNARY else 2):\n raise ValueError(\"wrong arity\")\n if any(not re.fullmatch(rf\"(?:{NAME}|[01X]+)\", a) for a in args):\n raise ValueError(\"invalid operand\")\n gates[name] = (op, args)\n else:\n raise ValueError(\"invalid source line\")\n if not outputs:\n raise ValueError(\"no outputs\")\n return inputs, gates, outputs\n\n\ndef logic(op, a, b=None):\n if op == \"BUF\":\n return a\n if op == \"NOT\":\n return {\"0\": \"1\", \"1\": \"0\", \"X\": \"X\"}[a]\n if op in {\"AND\", \"NAND\"}:\n result = \"0\" if \"0\" in (a, b) else (\"1\" if a == b == \"1\" else \"X\")\n elif op in {\"OR\", \"NOR\"}:\n result = \"1\" if \"1\" in (a, b) else (\"0\" if a == b == \"0\" else \"X\")\n else:\n result = \"X\" if \"X\" in (a, b) else (\"1\" if a != b else \"0\")\n return logic(\"NOT\", result) if op in {\"NAND\", \"NOR\", \"XNOR\"} else result\n\n\ndef evaluate(circuit, values):\n inputs, gates, outputs = circuit\n if not isinstance(values, dict) or set(values) != set(inputs):\n raise ValueError(\"provide exactly the declared inputs\")\n for name, width in inputs.items():\n value = values[name]\n if not isinstance(value, str) or not re.fullmatch(\"[01X]+\", value) or len(value) != width:\n raise ValueError(\"invalid input value or width\")\n cache, active = dict(values), set()\n\n def resolve(name):\n if name not in inputs and name not in gates and re.fullmatch(\"[01X]+\", name):\n return name\n if name in cache:\n return cache[name]\n if name in active:\n raise ValueError(\"cycle\")\n if name not in gates:\n raise ValueError(\"undefined signal\")\n active.add(name)\n op, args = gates[name]\n operands = [resolve(arg) for arg in args]\n width = max(map(len, operands))\n if any(len(value) not in (1, width) for value in operands):\n raise ValueError(\"incompatible widths\")\n expanded = [value * width if len(value) == 1 else value for value in operands]\n cache[name] = \"\".join(logic(op, *bits) for bits in zip(*expanded))\n active.remove(name)\n return cache[name]\n\n for name in gates:\n resolve(name)\n return {name: resolve(name) for name in outputs}\n\n\ndef main():\n parser = argparse.ArgumentParser(description=\"Evaluate a circuit\")\n parser.add_argument(\"path\")\n parser.add_argument(\"--inputs\", required=True, help=\"JSON object of bitstrings\")\n args = parser.parse_args()\n try:\n circuit = parse_source(Path(args.path).read_text())\n print(json.dumps(evaluate(circuit, json.loads(args.inputs)), sort_keys=True))\n except (ValueError, OSError, RecursionError) as exc:\n print(str(exc), file=sys.stderr)\n return 2\n return 0\n\n\nif __name__ == \"__main__\":\n sys.exit(main())\n"}], "reference_B2": [{"path": "fusecircuit/__init__.py", "content": ""}, {"path": "fusecircuit/__main__.py", "content": "import argparse\nimport json\nimport re\nimport sys\nfrom pathlib import Path\n\n\nNAME = r\"[A-Za-z_][A-Za-z0-9_]*\"\nUNARY = {\"NOT\", \"BUF\"}\nBINARY = {\"AND\", \"OR\", \"XOR\", \"NAND\", \"NOR\", \"XNOR\"}\n\n\ndef parse_source(text):\n inputs, gates, outputs = {}, {}, []\n for raw in text.splitlines():\n line = raw.split(\"#\", 1)[0].strip()\n if not line:\n continue\n inp = re.fullmatch(rf\"INPUT\\s+({NAME})\\s+([1-9][0-9]*)\", line)\n out = re.fullmatch(rf\"OUTPUT\\s+({NAME})\", line)\n gate = re.fullmatch(rf\"({NAME})\\s*=\\s*([A-Z]+)\\((.*?)\\)\", line)\n if inp:\n name, width = inp.groups()\n if name in inputs or name in gates:\n raise ValueError(\"duplicate signal\")\n inputs[name] = int(width)\n elif out:\n name = out[1]\n if name in outputs:\n raise ValueError(\"duplicate output\")\n outputs.append(name)\n elif gate:\n name, op, body = gate.groups()\n args = [arg.strip() for arg in body.split(\",\")]\n if name in inputs or name in gates or not isinstance(op, str) or op not in UNARY | BINARY:\n raise ValueError(\"duplicate signal or unsupported operator\")\n if len(args) != (1 if op in UNARY else 2):\n raise ValueError(\"wrong arity\")\n if any(not re.fullmatch(rf\"(?:{NAME}|[01]+)\", a) for a in args):\n raise ValueError(\"invalid operand\")\n gates[name] = (op, args)\n else:\n raise ValueError(\"invalid source line\")\n if not outputs:\n raise ValueError(\"no outputs\")\n return inputs, gates, outputs\n\n\ndef logic(op, a, b=None):\n if op == \"BUF\":\n return a\n if op == \"NOT\":\n return \"1\" if a == \"0\" else \"0\"\n if op in {\"AND\", \"NAND\"}:\n result = \"1\" if a == b == \"1\" else \"0\"\n elif op in {\"OR\", \"NOR\"}:\n result = \"1\" if \"1\" in (a, b) else \"0\"\n else:\n result = \"1\" if a != b else \"0\"\n return logic(\"NOT\", result) if op in {\"NAND\", \"NOR\", \"XNOR\"} else result\n\n\ndef evaluate(circuit, values):\n inputs, gates, outputs = circuit\n if not isinstance(values, dict) or set(values) != set(inputs):\n raise ValueError(\"provide exactly the declared inputs\")\n for name, width in inputs.items():\n value = values[name]\n if not isinstance(value, str) or not re.fullmatch(\"[01]+\", value) or len(value) != width:\n raise ValueError(\"invalid input value or width\")\n cache, active = dict(values), set()\n\n def resolve(name):\n if re.fullmatch(\"[01]+\", name):\n return name\n if name in cache:\n return cache[name]\n if name in active:\n raise ValueError(\"cycle\")\n if name not in gates:\n raise ValueError(\"undefined signal\")\n active.add(name)\n op, args = gates[name]\n operands = [resolve(arg) for arg in args]\n width = max(map(len, operands))\n if any(len(value) not in (1, width) for value in operands):\n raise ValueError(\"incompatible widths\")\n expanded = [value * width if len(value) == 1 else value for value in operands]\n cache[name] = \"\".join(logic(op, *bits) for bits in zip(*expanded))\n active.remove(name)\n return cache[name]\n\n for name in gates:\n resolve(name)\n return {name: resolve(name) for name in outputs}\n\n\n\ndef parse_json(text):\n def unique(pairs):\n result = {}\n for key, value in pairs:\n if key in result:\n raise ValueError(\"duplicate JSON key\")\n result[key] = value\n return result\n obj = json.loads(text, object_pairs_hook=unique)\n if not isinstance(obj, dict) or set(obj) != {\"inputs\", \"gates\", \"outputs\"}:\n raise ValueError(\"invalid JSON circuit\")\n if not isinstance(obj[\"inputs\"], dict) or not isinstance(obj[\"gates\"], list) or not isinstance(obj[\"outputs\"], list):\n raise ValueError(\"invalid JSON field types\")\n lines = []\n for name, width in obj[\"inputs\"].items():\n if not re.fullmatch(NAME, name) or type(width) is not int or width < 1:\n raise ValueError(\"invalid JSON input\")\n lines.append(f\"INPUT {name} {width}\")\n for gate in obj[\"gates\"]:\n if not isinstance(gate, dict) or set(gate) != {\"name\", \"op\", \"args\"}:\n raise ValueError(\"invalid JSON gate\")\n name, op, args = gate[\"name\"], gate[\"op\"], gate[\"args\"]\n if not isinstance(name, str) or not re.fullmatch(NAME, name) or not isinstance(op, str) or op not in UNARY | BINARY:\n raise ValueError(\"invalid gate name or operator\")\n if not isinstance(args, list) or any(not isinstance(arg, str) or not re.fullmatch(rf\"(?:{NAME}|[01]+)\", arg) for arg in args):\n raise ValueError(\"invalid JSON operands\")\n lines.append(f\"{name} = {op}({','.join(args)})\")\n for name in obj[\"outputs\"]:\n if not isinstance(name, str) or not re.fullmatch(NAME, name):\n raise ValueError(\"invalid JSON output\")\n lines.append(f\"OUTPUT {name}\")\n return parse_source(\"\\n\".join(lines))\n\n\ndef parse_bench(text):\n lines = []\n for raw in text.splitlines():\n line = raw.split(\"#\", 1)[0].strip()\n if not line:\n continue\n declaration = re.fullmatch(rf\"(INPUT|OUTPUT)\\s*\\(\\s*({NAME})\\s*\\)\", line)\n if declaration:\n kind, name = declaration.groups()\n lines.append(f\"INPUT {name} 1\" if kind == \"INPUT\" else f\"OUTPUT {name}\")\n elif re.fullmatch(rf\"{NAME}\\s*=\\s*[A-Z]+\\(.*\\)\", line):\n lines.append(line)\n else:\n raise ValueError(\"invalid BENCH line\")\n circuit = parse_source(\"\\n\".join(lines))\n for _, args in circuit[1].values():\n if any(re.fullmatch(\"[01]+\", arg) and len(arg) != 1 for arg in args):\n raise ValueError(\"BENCH literals must be scalar\")\n return circuit\n\n\ndef main():\n parser = argparse.ArgumentParser(description=\"Evaluate a circuit\")\n parser.add_argument(\"path\")\n parser.add_argument(\"--format\", choices=[\"source\", \"json\", \"bench\"], default=\"source\")\n parser.add_argument(\"--inputs\", required=True, help=\"JSON object of bitstrings\")\n args = parser.parse_args()\n try:\n circuit = {\"source\": parse_source, \"json\": parse_json, \"bench\": parse_bench}[args.format](Path(args.path).read_text())\n print(json.dumps(evaluate(circuit, json.loads(args.inputs)), sort_keys=True))\n except (ValueError, OSError, RecursionError) as exc:\n print(str(exc), file=sys.stderr)\n return 2\n return 0\n\n\nif __name__ == \"__main__\":\n sys.exit(main())\n"}], "tests_A": [{"path": "test_current.py", "content": "import itertools\nimport random\nimport os\nimport subprocess\nimport sys\nfrom evaluator.contract import Contract,run_candidate\n\n\nclass Current(Contract):\n def test_cli_help_and_missing_arguments(self):\n prefix = [sys.executable,\"-m\",\"fusecircuit\"]\n result = run_candidate(prefix+[\"--help\"],os.environ['FUSE_REPO'])\n self.assertEqual(result.returncode,0)\n self.assertIn(\"--inputs\",result.stdout)\n result = run_candidate(prefix,os.environ['FUSE_REPO'])\n self.assertNotEqual(result.returncode,0)\n def test_all_scalar_truth_tables(self):\n functions = {\"AND\": lambda a,b:a&b, \"OR\": lambda a,b:a|b, \"XOR\": lambda a,b:a^b,\n \"NAND\": lambda a,b:1-(a&b), \"NOR\": lambda a,b:1-(a|b), \"XNOR\": lambda a,b:1-(a^b)}\n for op, function in functions.items():\n for a,b in itertools.product(range(2), repeat=2):\n with self.subTest(op=op,a=a,b=b):\n self.good(f\"INPUT a 1\\nINPUT b 1\\ny = {op}(a,b)\\nOUTPUT y\", {\"a\":str(a),\"b\":str(b)}, {\"y\":str(function(a,b))})\n for a in range(2):\n self.good(\"INPUT a 1\\nn = NOT(a)\\nb = BUF(a)\\nOUTPUT n\\nOUTPUT b\", {\"a\":str(a)}, {\"n\":str(1-a),\"b\":str(a)})\n\n def test_random_vectors(self):\n rng = random.Random(819)\n for width in [2,3,7,17,64]:\n a = \"\".join(rng.choice(\"01\") for _ in range(width))\n b = \"\".join(rng.choice(\"01\") for _ in range(width))\n expected = \"\".join(str(int(x)^int(y)) for x,y in zip(a,b))\n self.good(f\"INPUT a {width}\\nINPUT b {width}\\ny = XOR(a,b)\\nOUTPUT y\", {\"a\":a,\"b\":b}, {\"y\":expected})\n\n def test_vector_all_operators(self):\n self.good(\"INPUT a 4\\nINPUT b 4\\nand = AND(a,b)\\nor = OR(a,b)\\nxor = XOR(a,b)\\nnand = NAND(a,b)\\nnor = NOR(a,b)\\nxnor = XNOR(a,b)\\nnot = NOT(a)\\nbuf = BUF(a)\\n\" + \"\\n\".join(\"OUTPUT \"+op for op in [\"and\",\"or\",\"xor\",\"nand\",\"nor\",\"xnor\",\"not\",\"buf\"]),\n {\"a\":\"0011\",\"b\":\"0101\"}, {\"and\":\"0001\",\"or\":\"0111\",\"xor\":\"0110\",\"nand\":\"1110\",\"nor\":\"1000\",\"xnor\":\"1001\",\"not\":\"1100\",\"buf\":\"0011\"})\n\n def test_broadcast_each_side(self):\n self.good(\"INPUT a 4\\nINPUT b 1\\nu = AND(a,b)\\nv = XOR(b,a)\\nw = OR(0,a)\\nOUTPUT u\\nOUTPUT v\\nOUTPUT w\", {\"a\":\"0101\",\"b\":\"1\"}, {\"u\":\"0101\",\"v\":\"1010\",\"w\":\"0101\"})\n\n def test_literals_order_comments_outputs(self):\n self.good(\" # comment\\nOUTPUT y\\n y = XOR(a,1100) # note\\nINPUT a 4\\nOUTPUT a\\n\", {\"a\":\"1010\"}, {\"y\":\"0110\",\"a\":\"1010\"})\n self.good(\"y = NOT(0011)\\nOUTPUT y\", {}, {\"y\":\"1100\"})\n\n def test_names_and_signal_X(self):\n self.good(\"INPUT X 1\\nINPUT x 1\\n_result = XOR(X,x)\\nOUTPUT _result\", {\"X\":\"1\",\"x\":\"0\"}, {\"_result\":\"1\"})\n\n def test_bad_values(self):\n for values in [{},{\"a\":\"0\",\"extra\":\"1\"},{\"a\":1},{\"a\":True},{\"a\":None},{\"a\":\"\"},{\"a\":\"2\"},{\"a\":\"Z\"},{\"a\":\"00\"},[],None]:\n with self.subTest(values=values):\n self.bad(\"INPUT a 1\\nOUTPUT a\", values)\n\n def test_bad_syntax(self):\n for source in [\"\", \"INPUT a 0\\nOUTPUT a\", \"INPUT 9a 1\\nOUTPUT 9a\", \"INPUT a -1\\nOUTPUT a\", \"INPUT a 1\\nINPUT a 1\\nOUTPUT a\", \"INPUT a 1\\na = BUF(0)\\nOUTPUT a\", \"a = BUF(0)\\na = NOT(1)\\nOUTPUT a\", \"a = MUX(0,1)\\nOUTPUT a\", \"a = and(0,1)\\nOUTPUT a\", \"a = NOT(0,1)\\nOUTPUT a\", \"a = AND(0)\\nOUTPUT a\", \"a = BUF()\\nOUTPUT a\", \"a = AND(0,)\\nOUTPUT a\", \"a = BUF(2)\\nOUTPUT a\", \"a = BUF(1)\\nOUTPUT a\\nOUTPUT a\", \"OUTPUT missing\", \"a = BUF(b)\\nb = BUF(a)\\nOUTPUT a\", \"a = BUF(1)\\nb = BUF(missing)\\nOUTPUT a\", \"a = BUF(1)\\nb = BUF(c)\\nc = BUF(b)\\nOUTPUT a\"]:\n with self.subTest(source=source):\n self.bad(source, {})\n\n def test_bad_vector_widths(self):\n self.bad(\"INPUT a 2\\nINPUT b 3\\ny = AND(a,b)\\nOUTPUT y\", {\"a\":\"01\",\"b\":\"010\"})\n self.bad(\"INPUT a 4\\ny = AND(a,01)\\nOUTPUT y\", {\"a\":\"0101\"})\n"}], "tests_B1": [{"path": "test_unknown.py", "content": "import itertools\nfrom evaluator.contract import Contract\n\n\ndef expected(op,a,b):\n if op in {\"AND\",\"NAND\"}:\n value = \"0\" if \"0\" in (a,b) else (\"1\" if a==b==\"1\" else \"X\")\n elif op in {\"OR\",\"NOR\"}:\n value = \"1\" if \"1\" in (a,b) else (\"0\" if a==b==\"0\" else \"X\")\n else:\n value = \"X\" if \"X\" in (a,b) else str(int(a)^int(b))\n return {\"0\":\"1\",\"1\":\"0\",\"X\":\"X\"}[value] if op in {\"NAND\",\"NOR\",\"XNOR\"} else value\n\n\nclass Unknown(Contract):\n def test_every_truth_table(self):\n for op in [\"AND\",\"OR\",\"XOR\",\"NAND\",\"NOR\",\"XNOR\"]:\n for a,b in itertools.product(\"01X\",repeat=2):\n with self.subTest(op=op,a=a,b=b):\n self.good(f\"INPUT a 1\\nINPUT b 1\\ny = {op}(a,b)\\nOUTPUT y\", {\"a\":a,\"b\":b}, {\"y\":expected(op,a,b)})\n\n def test_unknown_unary(self):\n self.good(\"INPUT a 3\\nb = BUF(a)\\nn = NOT(a)\\nOUTPUT b\\nOUTPUT n\", {\"a\":\"01X\"}, {\"b\":\"01X\",\"n\":\"10X\"})\n\n def test_literals_vectors_broadcast(self):\n self.good(\"INPUT a 4\\nb = AND(a,X)\\nc = OR(X,a)\\nd = XOR(a,01XX)\\nOUTPUT b\\nOUTPUT c\\nOUTPUT d\", {\"a\":\"010X\"}, {\"b\":\"0X0X\",\"c\":\"X1XX\",\"d\":\"00XX\"})\n self.good(\"a = NOT(X)\\nOUTPUT a\", {}, {\"a\":\"X\"})\n\n def test_preserve_declared_X_name(self):\n self.good(\"INPUT X 3\\nb = BUF(X)\\nOUTPUT b\", {\"X\":\"01X\"}, {\"b\":\"01X\"})\n\n def test_unknown_invalid(self):\n for value in [\"x\",\"?\",\"Z\",\"0X0\"]:\n self.bad(\"INPUT a 1\\nOUTPUT a\", {\"a\":value})\n self.bad(\"a = AND(XX,101)\\nOUTPUT a\", {})\n"}], "tests_B2": [{"path": "test_formats.py", "content": "import json\nfrom evaluator.contract import Contract\n\n\ndef circuit():\n return {\"inputs\":{\"a\":4,\"b\":1},\"gates\":[{\"name\":\"n\",\"op\":\"AND\",\"args\":[\"a\",\"b\"]},{\"name\":\"y\",\"op\":\"NOT\",\"args\":[\"n\"]}],\"outputs\":[\"y\"]}\n\n\nclass Formats(Contract):\n def test_json_vectors_and_explicit_source(self):\n self.good(json.dumps(circuit()), {\"a\":\"0011\",\"b\":\"1\"}, {\"y\":\"1100\"}, \"json\")\n self.good(\"INPUT a 4\\ny = NOT(a)\\nOUTPUT y\", {\"a\":\"0011\"}, {\"y\":\"1100\"}, \"source\")\n\n def test_scalar_equivalence_all_ops(self):\n for op,result in [(\"AND\",\"0\"),(\"OR\",\"1\"),(\"XOR\",\"1\"),(\"NAND\",\"1\"),(\"NOR\",\"0\"),(\"XNOR\",\"0\")]:\n obj={\"inputs\":{\"a\":1,\"b\":1},\"gates\":[{\"name\":\"y\",\"op\":op,\"args\":[\"a\",\"b\"]}],\"outputs\":[\"y\",\"a\"]}\n self.good(json.dumps(obj), {\"a\":\"0\",\"b\":\"1\"}, {\"y\":result,\"a\":\"0\"}, \"json\")\n self.good(f\"OUTPUT(y)\\n INPUT(a) # hi\\nINPUT(b)\\ny = {op}(a,b)\\nOUTPUT(a)\", {\"a\":\"0\",\"b\":\"1\"}, {\"y\":result,\"a\":\"0\"}, \"bench\")\n self.good(\"INPUT(a)\\ny = BUF(a)\\nz = NOT(y)\\nOUTPUT(z)\", {\"a\":\"1\"}, {\"z\":\"0\"}, \"bench\")\n\n def test_json_validation(self):\n cases=[{},[],{\"inputs\":[],\"gates\":[],\"outputs\":[\"x\"]}]\n for field,value in [(\"inputs\",{\"a\":True}),(\"inputs\",{\"a\":0}),(\"inputs\",{\"a\":1.0}),(\"inputs\",{\"bad-name\":1}),(\"outputs\",[]),(\"outputs\",[1]),(\"outputs\",[\"missing\"]),(\"gates\",[{\"name\":\"y\",\"op\":[],\"args\":[]}]),(\"gates\",[{\"name\":\"y\",\"op\":\"NOT\",\"args\":[0]}]),(\"gates\",[{\"name\":\"y\",\"op\":\"NOT\",\"args\":\"a\"}]),(\"gates\",[{\"name\":\"y\",\"op\":\"NOT\",\"args\":[\"a\"],\"extra\":1}])]:\n obj=circuit();obj[field]=value;cases.append(obj)\n obj=circuit();obj['extra']=0;cases.append(obj)\n obj=circuit();obj['gates'].append(obj['gates'][0]);cases.append(obj)\n for obj in cases:\n with self.subTest(obj=obj): self.bad(json.dumps(obj), {\"a\":\"0011\",\"b\":\"1\"}, \"json\")\n for raw in ['{\"inputs\":{},\"inputs\":{},\"gates\":[],\"outputs\":[\"a\"]}', '{\"inputs\":{\"a\":1,\"a\":1},\"gates\":[],\"outputs\":[\"a\"]}', '{broken']:\n self.bad(raw, {\"a\":\"1\"}, \"json\")\n\n def test_bench_validation(self):\n for source in [\"INPUT(a)\\nINPUT(a)\\nOUTPUT(a)\", \"INPUT(a)\\nOUTPUT(a)\\nOUTPUT(a)\", \"INPUT(a)\\ny = BUF(z)\\nOUTPUT(y)\", \"x = BUF(y)\\ny = BUF(x)\\nOUTPUT(x)\", \"y = BUF(01)\\nOUTPUT(y)\", \"y = MUX(0,1)\\nOUTPUT(y)\", \"INPUT a 1\\nOUTPUT(a)\", \"INPUT(a)\\ny = AND(a)\\nOUTPUT(y)\"]:\n with self.subTest(source=source): self.bad(source, {\"a\":\"0\"} if \"INPUT\" in source else {}, \"bench\")\n self.bad(\"INPUT(a)\\nOUTPUT(a)\", {\"a\":\"01\"}, \"bench\")\n\n def test_json_cycles_and_widths(self):\n self.bad(json.dumps({\"inputs\":{},\"gates\":[{\"name\":\"a\",\"op\":\"BUF\",\"args\":[\"b\"]},{\"name\":\"b\",\"op\":\"BUF\",\"args\":[\"a\"]}],\"outputs\":[\"a\"]}), {}, \"json\")\n obj=circuit();obj['inputs']['b']=2\n self.bad(json.dumps(obj), {\"a\":\"0011\",\"b\":\"01\"}, \"json\")\n\n def test_nested_gate_duplicate_keys(self):\n for gate in ('{\"name\":\"y\",\"name\":\"y\",\"op\":\"BUF\",\"args\":[\"a\"]}',\n '{\"name\":\"y\",\"op\":\"BUF\",\"op\":\"BUF\",\"args\":[\"a\"]}',\n '{\"name\":\"y\",\"op\":\"BUF\",\"args\":[\"a\"],\"args\":[\"a\"]}',\n '{\"name\":\"y\",\"n\\\\u0061me\":\"y\",\"op\":\"BUF\",\"args\":[\"a\"]}'):\n self.bad('{\"inputs\":{\"a\":1},\"gates\":['+gate+'],\"outputs\":[\"y\"]}',{'a':'1'},'json')\n self.good('{\"inputs\":{\"a\":1},\"gates\":[{\"name\":\"y\",\"op\":\"BUF\",\"args\":[\"a\"]}],\"outputs\":[\"y\"]}',{'a':'1'},{'y':'1'},'json')\n\n def test_unknown_format_and_unknown_values_remain_invalid(self):\n source='INPUT a 1\\ny = BUF(a)\\nOUTPUT y'\n self.bad(source,{'a':'1'},'unknown-format')\n obj={'inputs':{'a':1},'gates':[{'name':'y','op':'BUF','args':['a']}],'outputs':['y']}\n self.bad(json.dumps(obj),{'a':'X'},'json')\n obj['gates'][0]['args']=['X']\n self.bad(json.dumps(obj),{'a':'1'},'json')\n # X remains a legal declared signal name, distinct from unknown logic values.\n obj={'inputs':{'X':1},'gates':[],'outputs':['X']}\n self.good(json.dumps(obj),{'X':'0'},{'X':'0'},'json')\n"}], "num_tests_A": 10, "num_tests_B1": 5, "num_tests_B2": 7} {"instance_id": "fuse-dev/codesearch_001", "task": "codesearch_001", "status": "study task: run in the preliminary Gemma 4 study (suites sealed 6 November 2026)", "source": "adapted from a SlopCodeBench task family (problem repository commit 9cd9ca3a); rewritten for FUSE", "license": "Apache-2.0", "requirement_A": "# Code Search current requirement\n\nImplement `python -m fusecodesearch --request JSON`. Input has exactly `files` (list of `{path,language,source}`) and `pattern` string. Paths are distinct nonempty identifiers for supplied files; no filesystem access is required. Languages are `python` and `javascript`. Add JavaScript support and multi-token exact search to the starter's Python identifier search. Output is exactly `{matches:[{path,start,end,text},...]}` sorted lexicographically by path then increasing offsets. Offsets count Unicode code points, start inclusive/end exclusive; text is the original source slice. Include overlapping matches.\n\nToken spelling determines exact matches; whitespace and comments are ignored for matching but retained inside reported spans. String literals are single tokens and their spelling is compared literally; identifiers inside comments/strings cannot match an identifier query. Python lexing handles indentation, multiline strings, operators and line continuations. JavaScript subset supports identifiers (including Unicode letters and `$`), numeric literals, single/double/backtick strings with escapes, line/block comments, punctuation and common operators. Template interpolation, regex literals and JSX are outside this subset. The source and pattern must be lexically valid in each supplied language; no complete AST validation is required. Empty file lists are valid; an empty/whitespace-only pattern is invalid. Unsupported languages, malformed files, duplicate paths and invalid tokens fail nonzero with no stdout and an error on stderr.\n\nImplement only the documented current behavior.\n\n### Lexical boundaries\n\nThis is a tokenization benchmark, not a complete Python/JavaScript parser. Python uses standard-library tokenization: ignore NEWLINE, NL, INDENT, DEDENT, COMMENT and ENDMARKER; reject tokenization errors and non-whitespace error tokens. Patterns may be fragments that tokenize successfully even if they are not valid complete programs, such as `a b`; unmatched delimiters that cause tokenization errors are invalid. Lexical name tokens, including keyword spellings, are identifier tokens for this benchmark. A comment-only pattern is invalid when tokenized for a supplied file. With no supplied files, only the nonempty/non-whitespace pattern-string check applies; no language is inferred.\n\nThe JavaScript dialect greedily tokenizes these forms, without AST validation: whitespace; `//` line comments; `/* ... */` block comments; single/double/backtick quoted strings, where a backslash escapes the next non-newline character; identifiers matching `(?:[$A-Za-z_]|[^\\W\\d])[$\\w]*` under Python's Unicode regular-expression character classes; decimal digit sequences with an optional dot followed by digits; the operators `=== !== => == != <= >= && || ++ -- ...`; and single characters from `{ } ( ) [ ] . , ; : + * / % = ! < > ? & | ^ -`. Tokens are chosen in that order with longer listed operators before single characters. Any other character or an unclosed quote/comment is invalid. Numeric spelling is literal; exponent, radix and separator spellings have no special numeric-token meaning. Template interpolation, regex literals and JSX have no special syntax in this dialect. Quoted strings are opaque tokens; no escape decoding occurs for matching. As no AST is checked, a sequence of individually recognized tokens need not form a valid program. A `$name` identifier and a Python `...` token have ordinary literal meaning in A.\n", "requirement_B1": "Preserve exact A matching by default. Add optional `pattern_mode`, accepting only `exact` (the default) or `structural`. In exact mode every token retains its A literal meaning and matches have no `captures` field. In structural mode add richer token-structure search patterns: `$name` captures exactly one identifier token, repeated names require the same spelling, and anonymous `...` matches zero or more balanced tokens without unmatched parentheses/brackets/braces or semicolons. Strings remain single tokens, so punctuation inside them does not affect balance. Require at least one literal token; reject patterns made entirely of holes/wildcards. Named metavariables use ASCII identifier names. Match left-to-right from every token position; if an ellipsis has several valid lengths, choose the shortest length that allows the full remaining pattern to match. Return at most one match per starting token. Add `captures` to matches only when the pattern contains these features; literal-pattern A output stays unchanged. Captures map names (without `$`) to identifier spelling. This is token-structural matching, not AST equivalence. Preserve multilingual offsets, comment/string behavior and all A validation. Rewrite/fix operations remain deferred.\n\n### Pattern-mode compatibility and balance\n\n`files` and `pattern` remain required; `pattern_mode` is the only new request field. Unsupported modes fail. Only structural mode reserves `$name` and the standalone `...` token. A structural Python pattern permits adjacent `$` plus an ASCII identifier despite `$` being invalid in ordinary Python source; a JavaScript `$name` token uses the same capture rule. Source files still use the unchanged A lexer. There is no literal escape within structural mode: use exact mode to search literal `$name` or `...` tokens. Exact mode and an omitted mode preserve all A output and validation.\n\nEach ellipsis expansion must form a self-contained sequence with an empty delimiter stack initially and finally, correctly nested matching pairs throughout, and no semicolon token anywhere in the expansion. Literal delimiters outside the ellipsis do not supply its stack. String-token punctuation is opaque. For multiple ellipses, choose expansion lengths lexicographically from left to right, minimizing the first length that permits the entire remaining pattern to match, then the next. At least one non-hole/non-ellipsis literal token is required in structural mode. Captures appear only on structural matches with a hole or ellipsis, and are `{}` for ellipsis-only special patterns. Repeated capture names compare exact token spelling, including case. B1 adds no replacement or file-saving operation.\n", "requirement_B2": "Add optional `replacement` string and optional Boolean `apply` (default false, permitted only with replacement). Use A exact token matches; holes/wildcards retain no special meaning. Compute every proposed substitution against original source offsets. Reject overlapping substitutions, invalid apply/replacement types and lexically invalid rewritten sources atomically. With replacement return original A matches plus `changes` sorted by path, each `{path,before,after,diff}`, and `files` in original input order. `diff` is Python difflib-style unified text for changed files. Preview (`apply:false`) keeps files unchanged; apply returns rewritten files. Unchanged files have no change entry. Preserve unaffected bytes/code points and only replace matched spans, including whitespace/comments inside those spans. Each invocation is a single pass over original-source matches. It does not rescan its rewritten source. A later invocation may find newly created matches, including matches spanning a replacement boundary; global repeat-application idempotence is not required. No file-system writes are required; the caller saves returned files. Pattern generalization remains deferred.\n\nFor exact diff serialization use the result of joining `difflib.unified_diff(before.splitlines(keepends=True), after.splitlines(keepends=True), fromfile=path, tofile=path, n=3, lineterm=\"\\n\")`. Do not add a synthetic final newline or a `No newline at end of file` marker. Replacement may be empty. Validate the complete rewritten source in each supplied file using its A lexer before returning any result. For example, pattern `a b`, source `a a b`, replacement `b` produces `a b` on the first invocation and `b` on the second. These tokenize as fragments under A and demonstrate the permitted cross-boundary behavior.\n", "disclosure_B1": "Later add an opt-in structural pattern mode with named identifier metavariables, repeated-capture consistency and balanced anonymous wildcard sequences, preserving default exact-token matching.\n", "disclosure_B2": "Later add preview/apply exact-token rewrites with atomic overlap checks and diffs, preserving unmatched source.\n", "scope_boundary": null, "starter_files": [{"path": "README.md", "content": "# Multilingual exact token search\n\nWorking Python identifier-token search; no JavaScript or multi-token patterns.\n\nRun `python -m fusecodesearch --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n"}, {"path": "fusecodesearch.py", "content": "\nimport copy, io, json, re, tokenize\n\n\ndef lex(source,language,pattern=False):\n if not isinstance(source,str):raise ValueError('source must be text')\n if language!='python':raise ValueError('unsupported language')\n offsets=[0]\n for line in source.splitlines(keepends=True):offsets.append(offsets[-1]+len(line))\n result=[]\n try:\n for token in tokenize.generate_tokens(io.StringIO(source).readline):\n if token.type in (tokenize.NEWLINE,tokenize.NL,tokenize.INDENT,tokenize.DEDENT,tokenize.COMMENT,tokenize.ENDMARKER):continue\n if token.type==tokenize.ERRORTOKEN:\n if token.string.isspace():continue\n if not (pattern and token.string=='$'):raise ValueError('invalid Python token')\n start=offsets[token.start[0]-1]+token.start[1];end=offsets[token.end[0]-1]+token.end[1]\n result.append((token.string,start,end,'name' if token.type==tokenize.NAME else 'value'))\n except (tokenize.TokenError,IndentationError,SyntaxError) as error:raise ValueError('invalid Python source') from error\n return result\n\ndef handle(request):\n if not isinstance(request,dict) or set(request)-{'files','pattern'} or not {'files','pattern'}<=set(request) or not isinstance(request['files'],list) or not isinstance(request['pattern'],str) or not request['pattern'].strip():raise ValueError('invalid request')\n files=copy.deepcopy(request['files']);names=set();matches=[]\n for file in files:\n if not isinstance(file,dict) or set(file)!={'path','language','source'} or not isinstance(file['path'],str) or not file['path'] or file['path'] in names:raise ValueError('invalid/duplicate file')\n names.add(file['path'])\n if file['language']!='python' or not re.fullmatch(r'[A-Za-z_][A-Za-z_0-9]*',request['pattern']):raise ValueError('starter supports Python identifier search only')\n for value,start,end,kind in lex(file['source'],file['language']):\n if kind=='name' and value==request['pattern']:\n matches.append({'path':file['path'],'start':start,'end':end,'text':file['source'][start:end]})\n matches.sort(key=lambda m:(m['path'],m['start'],m['end']))\n result={'matches':matches}\n\n return result\n\nif __name__ == '__main__':\n import argparse, sys\n parser=argparse.ArgumentParser()\n parser.add_argument('--request', required=True)\n args=parser.parse_args()\n try:\n output=handle(json.loads(args.request))\n print(json.dumps(output,ensure_ascii=False,sort_keys=True))\n except (ValueError,TypeError,KeyError,IndexError) as error:\n print(type(error).__name__ + ': ' + str(error),file=sys.stderr)\n sys.exit(2)\n"}], "reference_A": [{"path": "README.md", "content": "# Multilingual exact token search\n\nImplements the documented current CLI contract.\n\nRun `python -m fusecodesearch --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n"}, {"path": "fusecodesearch.py", "content": "\nimport copy, io, json, re, tokenize\n\nJS=re.compile(r\"\\s+|//[^\\n]*|/\\*[\\s\\S]*?\\*/|'(?:\\\\.|[^'\\\\])*'|\\\"(?:\\\\.|[^\\\"\\\\])*\\\"|`(?:\\\\.|[^`\\\\])*`|(?:[$A-Za-z_]|[^\\W\\d])[$\\w]*|\\d+(?:\\.\\d+)?|===|!==|=>|==|!=|<=|>=|&&|\\|\\||\\+\\+|--|\\.\\.\\.|[{}()\\[\\].,;:+*/%=!<>?&|^-]\",re.UNICODE)\n\ndef lex(source,language,pattern=False):\n if not isinstance(source,str):raise ValueError('source must be text')\n if language=='javascript':\n result=[];pos=0\n while pos|==|!=|<=|>=|&&|\\|\\||\\+\\+|--|\\.\\.\\.|[{}()\\[\\].,;:+*/%=!<>?&|^-]\",re.UNICODE)\n\ndef lex(source,language,pattern=False):\n if not isinstance(source,str):raise ValueError('source must be text')\n if language=='javascript':\n result=[];pos=0\n while pos=len(tokens) or tokens[i+1][3]!='name' or tokens[i+1][1]!=end:raise ValueError('invalid metavariable')\n following=tokens[i+1]\n if not re.fullmatch(r'[A-Za-z_][A-Za-z_0-9]*',following[0]):raise ValueError('invalid metavariable')\n combined.append(('$'+following[0],start,following[2],'hole'));i+=2\n else:\n if value.startswith('$') and kind=='name':\n if not re.fullmatch(r'\\$[A-Za-z_][A-Za-z_0-9]*',value):raise ValueError('invalid metavariable')\n kind='hole'\n combined.append((value,start,end,kind));i+=1\n tokens=combined\n if not tokens:raise ValueError('empty pattern')\n if all(t[3]=='hole' or t[0]=='...' for t in tokens):raise ValueError('pattern requires a literal token')\n return tokens\n\ndef balanced(tokens):\n stack=[];pairs={')':'(',']':'[','}':'{'}\n for value,*_ in tokens:\n if value==';':return False\n if value in ('(','[','{'):stack.append(value)\n elif value in pairs:\n if not stack or stack.pop()!=pairs[value]:return False\n return not stack\n\ndef find(source,tokens,pattern):\n special=any(t[3]=='hole' or t[0]=='...' for t in pattern);result=[]\n def walk(index,p,captures):\n if p==len(pattern):return index,captures\n item=pattern[p]\n if item[0]=='...':\n for end in range(index,len(tokens)+1):\n if balanced(tokens[index:end]):\n found=walk(end,p+1,dict(captures))\n if found is not None:return found\n return None\n if index>=len(tokens):return None\n token=tokens[index]\n if item[3]=='hole':\n key=item[0][1:]\n if token[3]!='name' or key in captures and captures[key]!=token[0]:return None\n captures=dict(captures);captures[key]=token[0]\n elif item[0]!=token[0]:return None\n return walk(index+1,p+1,captures)\n for start in range(len(tokens)):\n found=walk(start,0,{})\n if found is None:continue\n end,captures=found\n if end<=start:continue\n left,right=tokens[start][1],tokens[end-1][2];match={'start':left,'end':right,'text':source[left:right]}\n if special:match['captures']=captures\n result.append(match)\n return result\n\ndef handle(request):\n if not isinstance(request,dict) or set(request)-{'files','pattern','pattern_mode'} or not {'files','pattern'}<=set(request) or not isinstance(request['files'],list) or not isinstance(request['pattern'],str) or not request['pattern'].strip():raise ValueError('invalid request')\n mode=request.get('pattern_mode','exact')\n if mode not in ('exact','structural'):raise ValueError('invalid pattern mode')\n files=copy.deepcopy(request['files']);names=set();matches=[]\n for file in files:\n if not isinstance(file,dict) or set(file)!={'path','language','source'} or not isinstance(file['path'],str) or not file['path'] or file['path'] in names:raise ValueError('invalid/duplicate file')\n names.add(file['path'])\n\n tokens=lex(file['source'],file['language'])\n if mode=='structural':pattern=pattern_tokens(request['pattern'],file['language'])\n else:\n pattern=lex(request['pattern'],file['language'])\n if not pattern:raise ValueError('empty pattern')\n if mode=='structural':found=find(file['source'],tokens,pattern)\n else:\n found=[];size=len(pattern)\n for start in range(len(tokens)-size+1):\n chosen=tokens[start:start+size]\n if [t[0] for t in chosen]==[t[0] for t in pattern]:\n left,right=chosen[0][1],chosen[-1][2]\n found.append({'start':left,'end':right,'text':file['source'][left:right]})\n for match in found:matches.append({'path':file['path'],**match})\n matches.sort(key=lambda m:(m['path'],m['start'],m['end']))\n result={'matches':matches}\n\n return result\n\nif __name__ == '__main__':\n import argparse, sys\n parser=argparse.ArgumentParser()\n parser.add_argument('--request', required=True)\n args=parser.parse_args()\n try:\n output=handle(json.loads(args.request))\n print(json.dumps(output,ensure_ascii=False,sort_keys=True))\n except (ValueError,TypeError,KeyError,IndexError) as error:\n print(type(error).__name__ + ': ' + str(error),file=sys.stderr)\n sys.exit(2)\n"}], "reference_B2": [{"path": "README.md", "content": "# Multilingual exact token search\n\nImplements the documented current CLI contract.\n\nRun `python -m fusecodesearch --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n"}, {"path": "fusecodesearch.py", "content": "import difflib\n\nimport copy, io, json, re, tokenize\n\nJS=re.compile(r\"\\s+|//[^\\n]*|/\\*[\\s\\S]*?\\*/|'(?:\\\\.|[^'\\\\])*'|\\\"(?:\\\\.|[^\\\"\\\\])*\\\"|`(?:\\\\.|[^`\\\\])*`|(?:[$A-Za-z_]|[^\\W\\d])[$\\w]*|\\d+(?:\\.\\d+)?|===|!==|=>|==|!=|<=|>=|&&|\\|\\||\\+\\+|--|\\.\\.\\.|[{}()\\[\\].,;:+*/%=!<>?&|^-]\",re.UNICODE)\n\ndef lex(source,language,pattern=False):\n if not isinstance(source,str):raise ValueError('source must be text')\n if language=='javascript':\n result=[];pos=0\n while posb['start'] for a,b in zip(selected,selected[1:])):raise ValueError('overlapping replacements')\n before=file['source'];after=before\n for match in reversed(selected):after=after[:match['start']]+request['replacement']+after[match['end']:]\n lex(after,file['language'])\n if before!=after:changes.append({'path':file['path'],'before':before,'after':after,'diff':''.join(difflib.unified_diff(before.splitlines(keepends=True),after.splitlines(keepends=True),fromfile=file['path'],tofile=file['path']))})\n file['source']=after\n changes.sort(key=lambda c:c['path']);result.update(changes=changes,files=rewritten if request.get('apply',False) else files)\n elif 'apply' in request:raise ValueError('apply requires replacement')\n return result\n\nif __name__ == '__main__':\n import argparse, sys\n parser=argparse.ArgumentParser()\n parser.add_argument('--request', required=True)\n args=parser.parse_args()\n try:\n output=handle(json.loads(args.request))\n print(json.dumps(output,ensure_ascii=False,sort_keys=True))\n except (ValueError,TypeError,KeyError,IndexError) as error:\n print(type(error).__name__ + ': ' + str(error),file=sys.stderr)\n sys.exit(2)\n"}], "tests_A": [{"path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusecodesearch'\n\n def search(self,source,pattern,language='python',**extra):return self.request({'files':[{'path':'a','language':language,'source':source}],'pattern':pattern,**extra})\n\n def test_python_sequences_comments_strings_and_spans(self):\n source='x = foo( 1 ) # foo(1)\\ns = \"foo(1)\"\\ny = foo(1)\\n';result=self.search(source,'foo(1)')\n self.assertEqual([m['text'] for m in result['matches']],['foo( 1 )','foo(1)'])\n for m in result['matches']:self.assertEqual(source[m['start']:m['end']],m['text'])\n self.assertEqual(len(self.search(source,'foo')['matches']),2)\n def test_javascript_comments_escaped_strings_and_unicode_offsets(self):\n source='const ölçü = 1; // log(x)\\nlog( ölçü ); const s=\"log(ölçü)\"; /* log(ölçü) */\\n'\n found=self.search(source,'log(ölçü)','javascript')['matches'];self.assertEqual(len(found),1);self.assertEqual(found[0]['text'],'log( ölçü )');self.assertEqual(found[0]['start'],source.index('log( ölçü'))\n def test_ordering_overlaps_and_exact_literal_spelling(self):\n files=[{'path':'z','language':'javascript','source':'a+a+a;'}, {'path':'b','language':'python','source':'a+a+a\\n'}]\n matches=self.request({'files':files,'pattern':'a+a'})['matches'];self.assertEqual([m['path'] for m in matches],['b','b','z','z'])\n self.assertEqual([m['start'] for m in matches],[0,2,0,2])\n self.assertEqual(len(self.search('x=\"a\"\\ny=\\'a\\'\\n','\"a\"')['matches']),1)\n def test_multiline_and_seeded_identifier_oracle(self):\n rng=random.Random(184);names=[rng.choice(['alpha','beta','gamma']) for _ in range(20)];source='\\n'.join(n+' = 1' for n in names)+'\\n'\n self.assertEqual(len(self.search(source,'beta')['matches']),names.count('beta'))\n source='call(\\n x, # keep\\n y\\n)\\n';self.assertEqual(self.search(source,'call(x,y)')['matches'][0]['text'],source.rstrip())\n def test_invalid_requests_and_empty_pattern(self):\n for req in [{'files':[],'pattern':''},{'files':[{'path':'x','language':'rust','source':'x'}],'pattern':'x'},{'files':[{'path':'x','language':'python','source':'x'},{'path':'x','language':'python','source':'x'}],'pattern':'x'},{'files':[{'path':'x','language':'javascript','source':'\"unclosed'}],'pattern':'x'}]:self.bad(req)\n self.assertEqual(self.request({'files':[],'pattern':'x'})['matches'],[])\n\n def test_unclosed_javascript_comment_is_invalid(self):\n self.bad({'files':[{'path':'a','language':'javascript','source':'/* unclosed'}],'pattern':'x'})\n\n def test_reserved_looking_tokens_retain_literal_meaning(self):\n js=self.search('$x+$x;', '$x', 'javascript')['matches']\n self.assertEqual([m['text'] for m in js],['$x','$x'])\n self.assertTrue(all('captures' not in m for m in js))\n py=self.search('x = ...\\n', '...')['matches']\n self.assertEqual([m['text'] for m in py],['...'])\n self.assertNotIn('captures',py[0])\n\n def test_comment_only_pattern_and_fragment_rules(self):\n self.bad({'files':[{'path':'a','language':'python','source':'x\\n'}],'pattern':'# comment'})\n self.bad({'files':[{'path':'a','language':'javascript','source':'x;'}],'pattern':'// comment'})\n self.assertEqual(self.search('a a b','a b')['matches'][0]['text'],'a b')\n\n def test_exact_nested_match_shape_and_offset_types(self):\n result=self.search('x x','x')\n self.assertEqual(result,{'matches':[{'path':'a','start':0,'end':1,'text':'x'},\n {'path':'a','start':2,'end':3,'text':'x'}]})\n for match in result['matches']:\n self.assertIs(type(match['start']),int);self.assertIs(type(match['end']),int)\n for file in ({'path':'a','language':'python','source':False},\n {'path':'a','language':'python','source':'x','extra':1}):\n self.bad({'files':[file],'pattern':'x'})\n"}], "tests_B1": [{"path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusecodesearch'\n\n def search(self,source,pattern,language='python',**extra):return self.request({'files':[{'path':'a','language':language,'source':source}],'pattern':pattern,'pattern_mode':'structural',**extra})\n\n def test_repeated_named_holes_and_capture_offsets(self):\n result=self.search('a+a\\na+b\\nz+z\\n','$x + $x')['matches'];self.assertEqual([m['text'] for m in result],['a+a','z+z']);self.assertEqual([m['captures'] for m in result],[{'x':'a'},{'x':'z'}])\n def test_balanced_ellipsis_nested_calls_zero_and_shortest(self):\n found=self.search('call()\\ncall(a, nested(b,c))\\ncall(\"(\")\\n','call(...)')['matches'];self.assertEqual([m['text'] for m in found],['call()','call(a, nested(b,c))','call(\"(\")'])\n result=self.search('f(a,b); f(c);','f(...)','javascript')['matches'];self.assertEqual([m['text'] for m in result],['f(a,b)','f(c)'])\n def test_identifier_holes_exclude_literals_and_pattern_needs_literal(self):\n self.assertEqual(len(self.search('f(1)\\nf(x)\\n','f($x)')['matches']),1)\n self.bad({'files':[{'path':'a','language':'python','source':'x\\n'}],'pattern':'$x','pattern_mode':'structural'})\n self.bad({'files':[{'path':'a','language':'javascript','source':'x;'}],'pattern':'...','pattern_mode':'structural'})\n\n def test_structural_mode_is_explicit_and_invalid_modes_fail(self):\n request={'files':[{'path':'a','language':'javascript','source':'$x+x;'}],'pattern':'$x'}\n self.assertEqual(self.request(request)['matches'][0]['text'],'$x')\n self.assertNotIn('captures',self.request(request)['matches'][0])\n self.assertEqual(self.request(dict(request,pattern_mode='exact')),self.request(request))\n self.bad(dict(request,pattern_mode='other'))\n self.bad(dict(request,pattern_mode=True))\n self.bad(dict(request,pattern_mode='structural'))\n\n def test_ellipsis_cannot_cross_a_semicolon(self):\n result = self.search('a;b', 'a ... b', language='javascript')\n self.assertEqual(result['matches'], [])\n\n def test_ellipsis_chooses_shortest_complete_match(self):\n result = self.search('a b b', 'a ... b', language='javascript')\n self.assertEqual([m['text'] for m in result['matches']], ['a b'])\n self.assertEqual(result['matches'][0]['captures'], {})\n\n def test_multiple_ellipses_choose_lengths_left_to_right(self):\n result = self.search('a b b c c', 'a ... b ... c', language='javascript')\n self.assertEqual([m['text'] for m in result['matches']], ['a b b c'])\n\n\n def test_crossed_unmatched_delimiters_and_opaque_string_tokens(self):\n for source in ('a ([)] b','a ( b','a ) b','a [{]} b'):\n self.assertEqual(self.search(source,'a ... b','javascript'),{'matches':[]})\n for source in ('a ([{x}]) b','a \"([)]\" b'):\n self.assertEqual(self.search(source,'a ... b','javascript'),{'matches':[\n {'path':'a','start':0,'end':len(source),'text':source,'captures':{}}]})\n\n def test_backtracking_restores_capture_bindings(self):\n source='start a end b end b'\n self.assertEqual(self.search(source,'start ... $x end $x','javascript'),{'matches':[\n {'path':'a','start':0,'end':len(source),'text':source,'captures':{'x':'b'}}]})\n self.assertEqual(self.search('start a end b','start ... $x end $x','javascript'),{'matches':[]})\n\n def test_ascii_capture_names_with_unicode_source_identifiers(self):\n for language in ('python','javascript'):\n payload={'files':[{'path':'a','language':language,'source':'π+π'}],\n 'pattern':'$é + $é','pattern_mode':'structural'}\n self.bad(payload)\n result=self.search('π+π','$x + $x',language)\n self.assertEqual(result,{'matches':[{'path':'a','start':0,'end':3,'text':'π+π','captures':{'x':'π'}}]})\n self.assertEqual(self.request({'files':[{'path':'a','language':'javascript','source':'$é'}],\n 'pattern':'$é','pattern_mode':'exact'}),{'matches':[{'path':'a','start':0,'end':2,'text':'$é'}]})\n"}], "tests_B2": [{"path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusecodesearch'\n\n def search(self,source,pattern,language='python',**extra):return self.request({'files':[{'path':'a','language':language,'source':source}],'pattern':pattern,**extra})\n\n def test_preview_apply_preserve_other_text_and_idempotence(self):\n source='x = old( 1 ) # old(1)\\ns=\"old(1)\"\\ny=old(1)\\n';preview=self.search(source,'old(1)',replacement='new(2)')\n self.assertEqual(preview['files'][0]['source'],source);self.assertEqual(len(preview['changes']),1)\n expected='x = new(2) # old(1)\\ns=\"old(1)\"\\ny=new(2)\\n';self.assertEqual(preview['changes'][0]['after'],expected);self.assertIn('--- a',preview['changes'][0]['diff'])\n applied=self.search(source,'old(1)',replacement='new(2)',apply=True);self.assertEqual(applied['files'][0]['source'],expected)\n again=self.request({'files':applied['files'],'pattern':'old(1)','replacement':'new(2)','apply':True});self.assertEqual(again['matches'],[]);self.assertEqual(again['changes'],[])\n def test_javascript_multifile_and_invalid_overlap(self):\n req={'files':[{'path':'z','language':'javascript','source':'old(x);'}, {'path':'a','language':'python','source':'old(x)\\n'}],'pattern':'old(x)','replacement':'new(x)','apply':True}\n result=self.request(req);self.assertEqual([c['path'] for c in result['changes']],['a','z']);self.assertEqual([f['path'] for f in result['files']],['z','a'])\n self.bad({'files':[{'path':'a','language':'javascript','source':'a+a+a;'}],'pattern':'a+a','replacement':'b','apply':True})\n self.bad({'files':req['files'],'pattern':'old(x)','replacement':'\"unclosed'})\n self.bad({'files':req['files'],'pattern':'old(x)','apply':True})\n\n def test_boundary_matches_can_appear_on_a_later_invocation(self):\n first=self.search('a a b','a b',replacement='b',apply=True)\n self.assertEqual(first['files'][0]['source'],'a b')\n self.assertEqual(len(first['matches']),1)\n second=self.request({'files':first['files'],'pattern':'a b','replacement':'b','apply':True})\n self.assertEqual(second['files'][0]['source'],'b')\n self.assertEqual(len(second['matches']),1)\n\n def test_exact_diff_missing_newline_and_empty_replacement(self):\n import difflib\n for source, replacement, expected in (('old(x)', 'new(x)', 'new(x)'),\n ('old(x)\\nkeep(y)\\n', 'new(x)', 'new(x)\\nkeep(y)\\n'),\n ('old(x);', '', ';')):\n with self.subTest(source=source, replacement=replacement):\n language='javascript' if source.endswith(';') else 'python'\n for apply in (False,True):\n result=self.search(source,'old(x)',language,replacement=replacement,apply=apply)\n exact=''.join(difflib.unified_diff(source.splitlines(keepends=True),\n expected.splitlines(keepends=True),fromfile='a',tofile='a',n=3,lineterm='\\n'))\n self.assertEqual(result['changes'],[{'path':'a','before':source,'after':expected,'diff':exact}])\n self.assertEqual(result['files'][0]['source'],expected if apply else source)\n self.assertEqual(result['matches'],[{'path':'a','start':0,'end':6,'text':'old(x)'}])\n\n def test_unchanged_file_omission_for_identical_and_absent_matches(self):\n files=[{'path':'z','language':'python','source':'keep(x)'},\n {'path':'a','language':'python','source':'old(x)'}]\n for apply in (False,True):\n result=self.request({'files':files,'pattern':'old(x)','replacement':'old(x)','apply':apply})\n self.assertEqual(result['changes'],[])\n self.assertEqual(result['files'],files)\n self.assertEqual(len(result['matches']),1)\n result=self.request({'files':files,'pattern':'old(x)','replacement':'new(x)'})\n self.assertEqual([c['path'] for c in result['changes']],['a'])\n self.assertEqual(result['files'],files)\n"}], "num_tests_A": 9, "num_tests_B1": 10, "num_tests_B2": 5} {"instance_id": "fuse-dev/textdrop_001", "task": "textdrop_001", "status": "study task: run in the preliminary Gemma 4 study (suites sealed 6 November 2026)", "source": "adapted from a SlopCodeBench task family (problem repository commit 9cd9ca3a); rewritten for FUSE", "license": "Apache-2.0", "requirement_A": "# TextDrop current requirement\n\nImplement a local note-store JSON CLI: `python -m fusetextdrop --request JSON`. Input has optional `state` and required `command`; output is `{\"state\":updated_state,\"result\":operation_result}`. Each invocation is a fresh process. The caller persists the returned state as JSON and supplies it to later calls. No server or external service is required. Missing/null state initializes `{\"version\":1,\"next_id\":1,\"notes\":{}}`; reject malformed state. Notes are keyed by decimal ID strings and contain `id`, `title`, `body`, `format`. IDs are positive, allocated monotonically without reuse and below `next_id`; `version` is integer 1.\n\nPreserve existing create/get/list/delete operations; add update, Markdown rendering and export/import. `create` requires title/body and optional format (default plain); returns note. `get`, `delete`, `update`, `render` require integer id. `list` returns notes in ascending ID order; delete returns `{\"deleted\":id}`. Update accepts one or more title/body/format fields and returns updated note. Title length is 1–120 Unicode code points; body is at most 10,000. Formats are plain or markdown. Unknown fields/operations, missing notes, wrong types and empty updates fail with nonzero exit, no stdout, and an error on stderr. Treat each request atomically.\n\n`render` returns `{\"html\":...}`. Plain text becomes an escaped `
...
`. Markdown supports one- to three-level headings, paragraphs separated by blank lines (internal newlines retained), `**bold**`, `*italic*`, HTTP/HTTPS links, and unlabelled triple-backtick code fences. Escape raw HTML, quotes and ampersands. Unsafe link schemes remain escaped literal Markdown; never emit their href. Unclosed fences fail. HTML blocks are joined by newlines. Inline nesting is outside this subset.\n\n`export` returns `{\"serialized\":JSON string}` representing the complete store. `import` requires `serialized`, validates the decoded store and replaces current state, returning `{\"imported\":note_count}`. Export/reload/import must preserve Unicode, note content, ordering and ID allocation. Implement only the documented current behavior.\n\n### Store and rendering details\n\nThe A request has exactly required `command` and optional `state`. The store has exactly `version`, `next_id`, `notes`; notes have exactly `id`, `title`, `body`, `format`. `version`, `next_id` and note/command IDs are integers, never Boolean. Note map keys are canonical positive decimal strings: no leading zeros, sign or spaces; each equals the decimal spelling of its embedded ID. Empty notes and gaps left by deletion are valid. No note ID may reach or exceed `next_id`. Export/import equality is equality of JSON data and note-ID ordering, not the order or whitespace of object serialization.\n\nMarkdown blocks use newline-separated lines: a heading begins with exactly one to three `#` followed by one space; an unlabelled code fence is a line exactly equal to three backticks. Whitespace-only lines separate paragraphs. Consecutive ordinary lines become one paragraph with internal newlines preserved. Code contents are escaped, with internal newlines preserved and no added final newline; unmatched opening fences fail when render is requested. Other heading/fence spellings are ordinary paragraph text.\n\nProcess inline forms from left to right over original text, never over generated HTML: links `[label](destination)` (nonempty label/destination, neither containing a newline; label has no `]`, destination has no parentheses), then `**text**`, then `*text*`. Emphasis contents are nonempty, contain neither `*` nor newline, and their enclosing asterisks cannot be adjacent to another asterisk. Unmatched/unsupported forms remain escaped literal text. No nesting: matched labels and emphasis contents are escaped verbatim, and markup in a URL is never interpreted. Link destinations must parse as HTTP/HTTPS with a nonempty network location; all other schemes/invalid destinations remain escaped literal Markdown. Escape `& < > \" '` everywhere in text/attributes using `& < > " '`. Join block HTML with one newline.\n\nExamples: body `**b** and *i*` renders `

b and i

`; `[**go**](https://example.org/a*b*)` renders `

**go**

`; `***x***` remains `

***x***

`; `[bad](javascript:alert)` remains `

[bad](javascript:alert)

`; a plain body containing a single quote renders `
'
`.\n", "requirement_B1": "Add local authenticated identity and lifecycle while preserving anonymous A behavior until accounts exist. Register with command `{op:\"register\",username,password}`; username is a nonempty identifier, password at least 8 code points, duplicate registration fails. Return `{registered:username}`. Login validates credentials and returns opaque nonempty `session`; subsequent requests use that top-level token. Invalid/missing tokens fail once an account exists. Never store plaintext passwords. Sessions survive state serialization. Logout invalidates the specified token; `delete_account` removes that account, all its sessions and owned notes, preserving other users. Creating notes while authenticated records ownership. Get/update/delete/render are restricted to the owner; list includes only owned notes. Existing anonymous notes remain stored but inaccessible while accounts exist. Import/export require authentication when accounts exist; trusted whole-store backup/restore is an administrative operation and not a privacy API. Receipt state is caller-owned in this local benchmark: it does not establish secure multi-tenant storage against hostile state tampering. No network service or production-security claim is required. Preserve A Markdown and persistence behavior. Selectable storage remains outside scope.\n\n### Bootstrap, deletion and backup lifecycle\n\nRegister and login are unauthenticated bootstrap commands, even when accounts already exist; an optional top-level session is ignored for those two operations. Registration of additional users remains public in this local benchmark. All other operations require a valid token whenever the account set is nonempty. Login sessions have no clock-based expiry; logout, account deletion or replacement by imported state controls validity. Logout/delete_account commands have exactly `op`. Return `{\"logged_out\":true}` or `{\"deleted_account\":username}` respectively. Registration/login require exactly `op`, `username`, `password`.\n\nBefore first registration, retain the exact A store and anonymous outputs. First registration adds identity state and an `owner:null` field to existing anonymous notes. Identity state has the A keys plus `accounts` (username to implementation-defined JSON credential-verifier record) and `sessions` (nonempty opaque token to registered username); every note adds `owner`, either a registered username or null. Validate the implementation's credential format and references, but no particular hashing or class design is prescribed. The public owner field is returned by create/get/list/update. Identity keys persist after the last account is deleted. Delete that user's owned notes and tokens, retain anonymous notes and `next_id`; with no accounts left, anonymous operations resume and newly created notes have owner null. Anonymous notes never transfer ownership automatically on registration.\n\nExport produces the entire current state, including identity information if present. Import/export are administrative whole-store backup operations, authenticated against the current state before execution when accounts exist. Import validates and replaces the entire state; it may restore either a valid A snapshot or an identity snapshot. Afterward the imported account/session set is authoritative: old tokens absent from it are invalid, and restored tokens resume validity. Importing an A snapshot removes identity state and resumes anonymous A behavior. These caller-owned backups are trusted, not a secure isolation boundary or a promise that one user cannot restore other users' data. B1 has no backend selector or journal envelope.\n", "requirement_B2": "Add a top-level `backend` selector, default `snapshot` retaining exactly A state and behavior, or `journal`. Both must support all A operations and identical result semantics. Journal state is `{version:1,backend:\"journal\",events:[{snapshot:A_state},...]}`. On mutation append a new snapshot while preserving the existing prefix exactly; reads/list/render/export do not append. Reopen the journal in a fresh process from returned JSON. Import replaces logical contents by appending when contents change. Export always returns portable A snapshot JSON that can be imported into either backend. Reject unknown backends, malformed journal entries or backend/state mismatches. This is a behavioral requirement for interchangeable stores; no prescribed class hierarchy. Identity and sessions remain outside scope.\n\n### Initialization and no-op rules\n\nMissing/null state initializes the selected backend: snapshot uses the A empty store; journal uses an empty events list and the A empty store as its logical contents. An explicitly empty journal is valid; each existing event has exactly `snapshot`, containing a complete valid A state. Only `backend:\"journal\"` accepts a journal envelope, and only snapshot accepts an A envelope. Reopening uses the final snapshot, or empty A state when there are no events.\n\nAppend exactly when an operation changes the logical JSON state. An update to the same values and an import of an equal logical snapshot do not append; changed imports append one snapshot. Equality ignores object-key order and serialization formatting, but preserves list order and field presence. Reads/list/render/export never append. Prefix preservation is equality of existing event JSON data and event order, not serialized bytes. Portable export contains only A state, so importing it into a journal never imports that source's event history. Results match A exactly.\n", "disclosure_B1": "Later add account registration, login sessions, note ownership and account/session lifecycle operations.\n", "disclosure_B2": "Later make storage selectable between snapshot and append-only journal backends, preserving note behavior across reloads.\n", "scope_boundary": null, "starter_files": [{"path": "README.md", "content": "# Persistent note snapshots and safe Markdown rendering\n\nWorking plain-text create/get/list/delete JSON note store.\n\nRun `python -m fusetextdrop --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n"}, {"path": "fusetextdrop.py", "content": "\nimport copy, json\n\ndef empty():return {'version':1,'next_id':1,'notes':{}}\n\ndef validate(state):\n if not isinstance(state,dict) or set(state)!={'version','next_id','notes'} or type(state['version']) is not int or state['version']!=1 or type(state['next_id']) is not int or state['next_id']<1 or not isinstance(state['notes'],dict):raise ValueError('invalid store')\n for key,note in state['notes'].items():\n if not isinstance(note,dict) or set(note)!={'id','title','body','format'} or type(note['id']) is not int or key!=str(note['id']) or not 010000 or note.get('format') not in ('plain',):raise ValueError('invalid content')\n\ndef handle(request):\n if not isinstance(request,dict) or set(request)-{'state','command'} or 'command' not in request:raise ValueError('invalid request')\n\n state=copy.deepcopy(empty() if request.get('state') is None else request['state']);validate(state)\n command=request['command']\n if not isinstance(command,dict):raise ValueError('invalid command')\n op=command.get('op')\n\n fields={'create':{'op','title','body','format'},'get':{'op','id'},'list':{'op'},'delete':{'op','id'},}\n if op not in fields or set(command)-fields[op]:raise ValueError('invalid command fields')\n if op=='create':\n if not {'title','body'}<=set(command):raise ValueError('missing content')\n identifier=state['next_id'];note={'id':identifier,'title':command['title'],'body':command['body'],'format':command.get('format','plain')}\n\n content(note);state['notes'][str(identifier)]=note;state['next_id']+=1;result=copy.deepcopy(note)\n elif op=='list':\n result=[copy.deepcopy(note) for _,note in sorted(state['notes'].items(),key=lambda item:int(item[0])) ]\n elif op in ('get','delete'):\n if type(command.get('id')) is not int or str(command['id']) not in state['notes']:raise ValueError('missing note')\n note=state['notes'][str(command['id'])]\n\n if op=='get':result=copy.deepcopy(note)\n elif op=='delete':del state['notes'][str(command['id'])];result={'deleted':command['id']}\n\n\n validate(state)\n output={'state':state,'result':result}\n\n return output\n\nif __name__ == '__main__':\n import argparse, sys\n parser=argparse.ArgumentParser()\n parser.add_argument('--request', required=True)\n args=parser.parse_args()\n try:\n output=handle(json.loads(args.request))\n print(json.dumps(output,ensure_ascii=False,sort_keys=True))\n except (ValueError,TypeError,KeyError,IndexError) as error:\n print(type(error).__name__ + ': ' + str(error),file=sys.stderr)\n sys.exit(2)\n"}], "reference_A": [{"path": "README.md", "content": "# Persistent note snapshots and safe Markdown rendering\n\nImplements the documented current CLI contract.\n\nRun `python -m fusetextdrop --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n"}, {"path": "fusetextdrop.py", "content": "\nimport copy, html, json, re\nfrom urllib.parse import urlsplit\n\ndef empty():return {'version':1,'next_id':1,'notes':{}}\n\ndef validate(state):\n if not isinstance(state,dict) or set(state)!={'version','next_id','notes'} or type(state['version']) is not int or state['version']!=1 or type(state['next_id']) is not int or state['next_id']<1 or not isinstance(state['notes'],dict):raise ValueError('invalid store')\n for key,note in state['notes'].items():\n if not isinstance(note,dict) or set(note)!={'id','title','body','format'} or type(note['id']) is not int or key!=str(note['id']) or not 010000 or note.get('format') not in ('plain','markdown'):raise ValueError('invalid content')\n\ndef render(note):\n if note['format']=='plain':return '
'+html.escape(note['body'])+'
'\n def inline(text):\n token=re.compile(r'\\[([^\\]\\n]+)\\]\\(([^()\\n]+)\\)|(?'+html.escape(label)+'')\n else:parts.append(html.escape(match.group()))\n elif bold is not None:parts.append(''+html.escape(bold)+'')\n else:parts.append(''+html.escape(italic)+'')\n position=match.end()\n parts.append(html.escape(text[position:]))\n return ''.join(parts)\n lines=note['body'].splitlines();parts=[];paragraph=[];i=0\n def flush():\n if paragraph:parts.append('

'+inline('\\n'.join(paragraph))+'

');paragraph.clear()\n while i'+html.escape('\\n'.join(code))+'')\n elif not line.strip():flush()\n elif re.match(r'^#{1,3} ',line):\n flush();level=len(line)-len(line.lstrip('#'));parts.append(f''+inline(line[level+1:])+f'')\n else:paragraph.append(line)\n i+=1\n flush();return '\\n'.join(parts)\n raise ValueError('unsupported rendering')\n\ndef handle(request):\n if not isinstance(request,dict) or set(request)-{'state','command'} or 'command' not in request:raise ValueError('invalid request')\n\n state=copy.deepcopy(empty() if request.get('state') is None else request['state']);validate(state)\n command=request['command']\n if not isinstance(command,dict):raise ValueError('invalid command')\n op=command.get('op')\n\n fields={'create':{'op','title','body','format'},'get':{'op','id'},'list':{'op'},'delete':{'op','id'},'update':{'op','id','title','body','format'},'render':{'op','id'},'export':{'op'},'import':{'op','serialized'}}\n if op not in fields or set(command)-fields[op]:raise ValueError('invalid command fields')\n if op=='create':\n if not {'title','body'}<=set(command):raise ValueError('missing content')\n identifier=state['next_id'];note={'id':identifier,'title':command['title'],'body':command['body'],'format':command.get('format','plain')}\n\n content(note);state['notes'][str(identifier)]=note;state['next_id']+=1;result=copy.deepcopy(note)\n elif op=='list':\n result=[copy.deepcopy(note) for _,note in sorted(state['notes'].items(),key=lambda item:int(item[0])) ]\n elif op in ('get','delete','update','render'):\n if type(command.get('id')) is not int or str(command['id']) not in state['notes']:raise ValueError('missing note')\n note=state['notes'][str(command['id'])]\n\n if op=='get':result=copy.deepcopy(note)\n elif op=='delete':del state['notes'][str(command['id'])];result={'deleted':command['id']}\n elif op=='update':\n if not set(command)&{'title','body','format'}:raise ValueError('empty update')\n for key in ('title','body','format'):\n if key in command:note[key]=command[key]\n content(note);result=copy.deepcopy(note)\n elif op=='render':result={'html':render(note)}\n elif op=='export':result={'serialized':json.dumps(state,ensure_ascii=False,sort_keys=True)}\n elif op=='import':\n if not isinstance(command.get('serialized'),str):raise ValueError('invalid serialized store')\n state=json.loads(command['serialized']);validate(state);result={'imported':len(state['notes'])}\n validate(state)\n output={'state':state,'result':result}\n\n return output\n\nif __name__ == '__main__':\n import argparse, sys\n parser=argparse.ArgumentParser()\n parser.add_argument('--request', required=True)\n args=parser.parse_args()\n try:\n output=handle(json.loads(args.request))\n print(json.dumps(output,ensure_ascii=False,sort_keys=True))\n except (ValueError,TypeError,KeyError,IndexError) as error:\n print(type(error).__name__ + ': ' + str(error),file=sys.stderr)\n sys.exit(2)\n"}], "reference_B1": [{"path": "README.md", "content": "# Persistent note snapshots and safe Markdown rendering\n\nImplements the documented current CLI contract.\n\nRun `python -m fusetextdrop --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n"}, {"path": "fusetextdrop.py", "content": "import hashlib, secrets\n\nimport copy, html, json, re\nfrom urllib.parse import urlsplit\n\ndef empty():return {'version':1,'next_id':1,'notes':{}}\n\ndef validate(state):\n if not isinstance(state,dict) or set(state)!=({'version','next_id','notes','accounts','sessions'} if 'accounts' in state else {'version','next_id','notes'}) or type(state['version']) is not int or state['version']!=1 or type(state['next_id']) is not int or state['next_id']<1 or not isinstance(state['notes'],dict):raise ValueError('invalid store')\n for key,note in state['notes'].items():\n if not isinstance(note,dict) or set(note)!=({'id','title','body','format','owner'} if 'accounts' in state else {'id','title','body','format'}) or type(note['id']) is not int or key!=str(note['id']) or not 010000 or note.get('format') not in ('plain','markdown'):raise ValueError('invalid content')\n\ndef render(note):\n if note['format']=='plain':return '
'+html.escape(note['body'])+'
'\n def inline(text):\n token=re.compile(r'\\[([^\\]\\n]+)\\]\\(([^()\\n]+)\\)|(?'+html.escape(label)+'')\n else:parts.append(html.escape(match.group()))\n elif bold is not None:parts.append(''+html.escape(bold)+'')\n else:parts.append(''+html.escape(italic)+'')\n position=match.end()\n parts.append(html.escape(text[position:]))\n return ''.join(parts)\n lines=note['body'].splitlines();parts=[];paragraph=[];i=0\n def flush():\n if paragraph:parts.append('

'+inline('\\n'.join(paragraph))+'

');paragraph.clear()\n while i'+html.escape('\\n'.join(code))+'')\n elif not line.strip():flush()\n elif re.match(r'^#{1,3} ',line):\n flush();level=len(line)-len(line.lstrip('#'));parts.append(f''+inline(line[level+1:])+f'')\n else:paragraph.append(line)\n i+=1\n flush();return '\\n'.join(parts)\n raise ValueError('unsupported rendering')\n\ndef handle(request):\n if not isinstance(request,dict) or set(request)-{'state','command','session'} or 'command' not in request:raise ValueError('invalid request')\n\n state=copy.deepcopy(empty() if request.get('state') is None else request['state']);validate(state)\n command=request['command']\n if not isinstance(command,dict):raise ValueError('invalid command')\n op=command.get('op')\n user=None\n if op=='register':\n if set(command)!={'op','username','password'} or not isinstance(command['username'],str) or not command['username'].isidentifier() or not isinstance(command['password'],str) or len(command['password'])<8 or command['username'] in state.get('accounts',{}):raise ValueError('invalid registration')\n state.setdefault('accounts',{});state.setdefault('sessions',{})\n for note in state['notes'].values():note.setdefault('owner',None)\n salt=secrets.token_hex(16);digest=hashlib.pbkdf2_hmac('sha256',command['password'].encode(),salt.encode(),10000).hex()\n state['accounts'][command['username']]={'salt':salt,'hash':digest}\n return {'state':state,'result':{'registered':command['username']}}\n if op=='login':\n if set(command)!={'op','username','password'} or not isinstance(command['username'],str) or not isinstance(command['password'],str) or command['username'] not in state.get('accounts',{}):raise ValueError('invalid login')\n account=state['accounts'][command['username']];digest=hashlib.pbkdf2_hmac('sha256',command['password'].encode(),account['salt'].encode(),10000).hex()\n if not secrets.compare_digest(digest,account['hash']):raise ValueError('invalid login')\n token=secrets.token_hex(24);state['sessions'][token]=command['username']\n return {'state':state,'result':{'session':token}}\n if state.get('accounts'):\n user=state.get('sessions',{}).get(request.get('session'))\n if user is None:raise ValueError('login required')\n if op in ('logout','delete_account'):\n if set(command)!={'op'} or user is None:raise ValueError('invalid lifecycle command')\n if op=='logout':del state['sessions'][request['session']];result={'logged_out':True}\n else:\n del state['accounts'][user];state['sessions']={t:u for t,u in state['sessions'].items() if u!=user};state['notes']={i:n for i,n in state['notes'].items() if n.get('owner')!=user};result={'deleted_account':user}\n return {'state':state,'result':result}\n fields={'create':{'op','title','body','format'},'get':{'op','id'},'list':{'op'},'delete':{'op','id'},'update':{'op','id','title','body','format'},'render':{'op','id'},'export':{'op'},'import':{'op','serialized'}}\n if op not in fields or set(command)-fields[op]:raise ValueError('invalid command fields')\n if op=='create':\n if not {'title','body'}<=set(command):raise ValueError('missing content')\n identifier=state['next_id'];note={'id':identifier,'title':command['title'],'body':command['body'],'format':command.get('format','plain')}\n if 'accounts' in state:note['owner']=user\n content(note);state['notes'][str(identifier)]=note;state['next_id']+=1;result=copy.deepcopy(note)\n elif op=='list':\n result=[copy.deepcopy(note) for _,note in sorted(state['notes'].items(),key=lambda item:int(item[0])) if not state.get('accounts') or note.get('owner')==user]\n elif op in ('get','delete','update','render'):\n if type(command.get('id')) is not int or str(command['id']) not in state['notes']:raise ValueError('missing note')\n note=state['notes'][str(command['id'])]\n if state.get('accounts') and note.get('owner')!=user:raise ValueError('access denied')\n if op=='get':result=copy.deepcopy(note)\n elif op=='delete':del state['notes'][str(command['id'])];result={'deleted':command['id']}\n elif op=='update':\n if not set(command)&{'title','body','format'}:raise ValueError('empty update')\n for key in ('title','body','format'):\n if key in command:note[key]=command[key]\n content(note);result=copy.deepcopy(note)\n elif op=='render':result={'html':render(note)}\n elif op=='export':result={'serialized':json.dumps(state,ensure_ascii=False,sort_keys=True)}\n elif op=='import':\n if not isinstance(command.get('serialized'),str):raise ValueError('invalid serialized store')\n state=json.loads(command['serialized']);validate(state);result={'imported':len(state['notes'])}\n validate(state)\n output={'state':state,'result':result}\n\n return output\n\nif __name__ == '__main__':\n import argparse, sys\n parser=argparse.ArgumentParser()\n parser.add_argument('--request', required=True)\n args=parser.parse_args()\n try:\n output=handle(json.loads(args.request))\n print(json.dumps(output,ensure_ascii=False,sort_keys=True))\n except (ValueError,TypeError,KeyError,IndexError) as error:\n print(type(error).__name__ + ': ' + str(error),file=sys.stderr)\n sys.exit(2)\n"}], "reference_B2": [{"path": "README.md", "content": "# Persistent note snapshots and safe Markdown rendering\n\nImplements the documented current CLI contract.\n\nRun `python -m fusetextdrop --request 'JSON'`. JSON responses use stdout; invalid requests exit nonzero with an error on stderr.\n"}, {"path": "fusetextdrop.py", "content": "\nimport copy, html, json, re\nfrom urllib.parse import urlsplit\n\ndef empty():return {'version':1,'next_id':1,'notes':{}}\n\ndef validate(state):\n if not isinstance(state,dict) or set(state)!={'version','next_id','notes'} or type(state['version']) is not int or state['version']!=1 or type(state['next_id']) is not int or state['next_id']<1 or not isinstance(state['notes'],dict):raise ValueError('invalid store')\n for key,note in state['notes'].items():\n if not isinstance(note,dict) or set(note)!={'id','title','body','format'} or type(note['id']) is not int or key!=str(note['id']) or not 010000 or note.get('format') not in ('plain','markdown'):raise ValueError('invalid content')\n\ndef render(note):\n if note['format']=='plain':return '
'+html.escape(note['body'])+'
'\n def inline(text):\n token=re.compile(r'\\[([^\\]\\n]+)\\]\\(([^()\\n]+)\\)|(?'+html.escape(label)+'')\n else:parts.append(html.escape(match.group()))\n elif bold is not None:parts.append(''+html.escape(bold)+'')\n else:parts.append(''+html.escape(italic)+'')\n position=match.end()\n parts.append(html.escape(text[position:]))\n return ''.join(parts)\n lines=note['body'].splitlines();parts=[];paragraph=[];i=0\n def flush():\n if paragraph:parts.append('

'+inline('\\n'.join(paragraph))+'

');paragraph.clear()\n while i'+html.escape('\\n'.join(code))+'')\n elif not line.strip():flush()\n elif re.match(r'^#{1,3} ',line):\n flush();level=len(line)-len(line.lstrip('#'));parts.append(f''+inline(line[level+1:])+f'')\n else:paragraph.append(line)\n i+=1\n flush();return '\\n'.join(parts)\n raise ValueError('unsupported rendering')\n\ndef handle(request):\n if not isinstance(request,dict) or set(request)-{'state','command','backend'} or 'command' not in request:raise ValueError('invalid request')\n backend=request.get('backend','snapshot');original=copy.deepcopy(request.get('state'));entries=[]\n if backend not in ('snapshot','journal'):raise ValueError('unknown backend')\n if backend=='journal':\n if original is not None:\n if not isinstance(original,dict) or set(original)!={'version','backend','events'} or type(original['version']) is not int or original['version']!=1 or original['backend']!='journal' or not isinstance(original['events'],list):raise ValueError('invalid journal')\n entries=copy.deepcopy(original['events'])\n for event in entries:\n if not isinstance(event,dict) or set(event)!={'snapshot'}:raise ValueError('invalid journal entry')\n validate(event['snapshot'])\n request=dict(request,state=copy.deepcopy(entries[-1]['snapshot']) if entries else empty())\n previous=copy.deepcopy(empty() if request.get('state') is None else request['state'])\n state=copy.deepcopy(empty() if request.get('state') is None else request['state']);validate(state)\n command=request['command']\n if not isinstance(command,dict):raise ValueError('invalid command')\n op=command.get('op')\n\n fields={'create':{'op','title','body','format'},'get':{'op','id'},'list':{'op'},'delete':{'op','id'},'update':{'op','id','title','body','format'},'render':{'op','id'},'export':{'op'},'import':{'op','serialized'}}\n if op not in fields or set(command)-fields[op]:raise ValueError('invalid command fields')\n if op=='create':\n if not {'title','body'}<=set(command):raise ValueError('missing content')\n identifier=state['next_id'];note={'id':identifier,'title':command['title'],'body':command['body'],'format':command.get('format','plain')}\n\n content(note);state['notes'][str(identifier)]=note;state['next_id']+=1;result=copy.deepcopy(note)\n elif op=='list':\n result=[copy.deepcopy(note) for _,note in sorted(state['notes'].items(),key=lambda item:int(item[0])) ]\n elif op in ('get','delete','update','render'):\n if type(command.get('id')) is not int or str(command['id']) not in state['notes']:raise ValueError('missing note')\n note=state['notes'][str(command['id'])]\n\n if op=='get':result=copy.deepcopy(note)\n elif op=='delete':del state['notes'][str(command['id'])];result={'deleted':command['id']}\n elif op=='update':\n if not set(command)&{'title','body','format'}:raise ValueError('empty update')\n for key in ('title','body','format'):\n if key in command:note[key]=command[key]\n content(note);result=copy.deepcopy(note)\n elif op=='render':result={'html':render(note)}\n elif op=='export':result={'serialized':json.dumps(state,ensure_ascii=False,sort_keys=True)}\n elif op=='import':\n if not isinstance(command.get('serialized'),str):raise ValueError('invalid serialized store')\n state=json.loads(command['serialized']);validate(state);result={'imported':len(state['notes'])}\n validate(state)\n output={'state':state,'result':result}\n if backend=='journal':\n if state!=previous:entries.append({'snapshot':copy.deepcopy(state)})\n output['state']={'version':1,'backend':'journal','events':entries}\n return output\n\nif __name__ == '__main__':\n import argparse, sys\n parser=argparse.ArgumentParser()\n parser.add_argument('--request', required=True)\n args=parser.parse_args()\n try:\n output=handle(json.loads(args.request))\n print(json.dumps(output,ensure_ascii=False,sort_keys=True))\n except (ValueError,TypeError,KeyError,IndexError) as error:\n print(type(error).__name__ + ': ' + str(error),file=sys.stderr)\n sys.exit(2)\n"}], "tests_A": [{"path": "test_contract.py", "content": "import json, random, unittest\nfrom evaluator.json_contract import JsonContract\nclass Acceptance(JsonContract):\n module='fusetextdrop'\n\n def step(self,state,op,**fields):return self.request({'state':state,'command':{'op':op,**fields}})\n def note(self,body='hello',format='plain'):return self.step(None,'create',title='Note',body=body,format=format)\n\n def test_persistence_unicode_update_delete_ids(self):\n one=self.note('Merhaba 測');two=self.step(json.loads(json.dumps(one['state'])),'create',title='Two',body='B')\n edit=self.step(two['state'],'update',id=1,title='Edited',body='C',format='markdown')\n self.assertEqual(edit['result']['body'],'C');deleted=self.step(edit['state'],'delete',id=1)\n three=self.step(deleted['state'],'create',title='Three',body='D');self.assertEqual(three['result']['id'],3)\n self.assertEqual([n['id'] for n in self.step(three['state'],'list')['result']],[2,3])\n def test_export_import_roundtrip(self):\n state=self.note('é 測')['state'];serialized=self.step(state,'export')['result']['serialized']\n loaded=self.step(None,'import',serialized=serialized);self.assertEqual(loaded['state'],state)\n self.assertEqual(self.step(loaded['state'],'get',id=1)['result']['body'],'é 測')\n def test_plain_escaping(self):\n n=self.note('