{
    "model": {
        "rank": 4261,
        "code": "thing-q160710",
        "model_id": "vr.tr.read-only-memory",
        "name": "read-only memory",
        "purpose": "Enable an AI agent to recognise read-only memory, assess whether its stored contents can be read reliably, and determine which programming, replacement or protection actions its implementation permits.",
        "family": "Thing Registry",
        "category": "Physical world and living systems",
        "status": "research-draft",
        "kind": "thing",
        "plane": "PHY",
        "domain": "PHY.OBJ",
        "industry": "",
        "version": "",
        "url": "/models/thing/q160710/",
        "tier": 2,
        "score": 77,
        "payload": {
            "layer": "wikidata",
            "aliases": [
                "functional cathode ray tube",
                "Nintendo optical disc",
                "Nintendo GameCube Disc",
                "Nintendo Wii Disc",
                "Nintendo Wii U Disc",
                "mask read-only memory",
                "Kanji-ROM",
                "556 series integrated circuits",
                "Boot ROM",
                "core rope memory",
                "TMS6100",
                "596 series integrated circuits"
            ],
            "aliasCount": 12,
            "merged": 12,
            "knownIn": 77,
            "facets": null,
            "markers": [],
            "lexicalClass": "",
            "senseRank": null,
            "alsoRegisteredAs": null,
            "source": {
                "dataset": "wikidata",
                "item": "Q160710",
                "url": "https://www.wikidata.org/wiki/Q160710",
                "license": "CC0 1.0"
            }
        },
        "research": {
            "vercy": "1.0-draft",
            "publication": {
                "status": "research-draft",
                "adjudicationStatus": "unreviewed",
                "publishableCanonical": false,
                "generatedAt": "2026-09-09T19:49:55Z",
                "providers": [
                    "Codex"
                ],
                "breadth": "recalled by Codex without web access - no source was read",
                "missingProviders": [],
                "pass": 2,
                "cost": {
                    "grok": {
                        "seconds": 22.4,
                        "error": "Reading additional input from stdin...\nOpenAI Codex v0.153.4\n--------\nworkdir: R:\\02_PROJECTS\\02_Meta_Models_Platforms\\Ver.cy\\current\\thing-registry-backlog\nmodel: gpt-6-astra\nprovider: openai\napproval: never\nsandbox: read-only\nreasoning effort: none\nreasoning summaries: none\nsession id: 01a087b7-381f-7d81-b2a9-04108e594d06\n--------\nuser\nDescribe what is already known about one registered thing. Answer as JSON only, no prose around it.\n\nThing: read-only memory\nSense to describe: (none recorded)\nDomain code: PHY.OBJ\nAlso known as: (none)\n\n\nContext for this batch of 695 things:\n# Batch 004: 1001",
                        "usd": 0,
                        "recall": true
                    },
                    "codex": {
                        "seconds": 69.4,
                        "error": "Reading additional input from stdin...\nOpenAI Codex v0.153.4\n--------\nworkdir: R:\\02_PROJECTS\\02_Meta_Models_Platforms\\Ver.cy\\current\\thing-registry-backlog\nmodel: gpt-6-astra\nprovider: openai\napproval: never\nsandbox: read-only\nreasoning effort: none\nreasoning summaries: none\nsession id: 01a087b7-382b-7010-ab4d-695461475e15\n--------\nuser\nYou are drafting a Vercy meta-model for one registered thing. Answer as JSON only, no prose around it.\n\nThing: read-only memory\nRegistry id: vr.tr.read-only-memory\nPlane / domain: PHY / PHY.OBJ\nRegistry definition: (none recorded)\nNames folded into this entry:"
                    }
                }
            },
            "metaModel": {
                "id": "THING-Q160710",
                "registryId": "vr.tr.read-only-memory",
                "name": "read-only memory",
                "version": "0.1.0-research.1",
                "entryKind": "thing",
                "family": "Thing Registry",
                "domain": [
                    "PHY.OBJ"
                ],
                "status": "research-draft"
            },
            "canonicalUrl": "https://ver.cy/models/thing/q160710/",
            "model": {
                "registry_id": "vr.tr.read-only-memory",
                "name": "read-only memory",
                "purpose": "Enable an AI agent to recognise read-only memory, assess whether its stored contents can be read reliably, and determine which programming, replacement or protection actions its implementation permits.",
                "definition": "Read-only memory (ROM) is nonvolatile digital memory whose contents are fixed during manufacture or programmed through a designated process and are read, rather than routinely rewritten, during normal operation.",
                "scope_statement": "This model owns read-only memory as a kind of physical nonvolatile memory device or embedded memory region, including how contents are established, addressed, retained and protected; it distinguishes the memory hardware from the information stored in it.",
                "in_scope": [
                    "Mask-programmed ROM, one-time-programmable ROM and explicitly identified erasable or electrically reprogrammable ROM implementations",
                    "Discrete ROM components and identifiable ROM regions embedded in larger devices",
                    "Storage organisation, addressing, read interfaces and electrical operating requirements",
                    "Programming or erasure mechanisms and the conditions that permit or prevent content changes",
                    "Content retention, read integrity, protection states and hardware replacement constraints"
                ],
                "out_of_scope": [
                    "Firmware algorithms, executable behaviour and software update policy",
                    "ROM image files, software archives and their licensing",
                    "Volatile memory and ordinary RAM made temporarily read-only through access permissions",
                    "General-purpose flash drives, solid-state drives and their storage controllers",
                    "Complete processors, computers or appliances containing ROM",
                    "Detailed semiconductor fabrication processes"
                ],
                "distinguishing_features": [
                    "The physical memory is intended to retain stored bits without continuous operating power; reading still requires the implementation's specified operating conditions.",
                    "Ordinary read operation does not provide unrestricted rewriting: content changes are impossible, one-time or dependent on a distinct programming or erasure mechanism.",
                    "A physical ROM device or region must be identifiable; a file called a ROM image is stored information rather than the memory hardware.",
                    "A RAM region with write permissions disabled does not become ROM merely because current software cannot write to it.",
                    "A flash or EEPROM implementation requires an explicit ROM classification or role; nonvolatility alone does not distinguish ROM from other storage."
                ],
                "characteristics": [
                    {
                        "name": "ROM implementation",
                        "kind": "category",
                        "unit_or_values": "mask ROM | one-time programmable ROM | EPROM | EEPROM | flash used as ROM | unresolved",
                        "why_it_matters": "Determines whether contents can change and which programming, erasure or replacement actions are physically possible."
                    },
                    {
                        "name": "Physical integration",
                        "kind": "category",
                        "unit_or_values": "discrete component | embedded memory region",
                        "why_it_matters": "Distinguishes a replaceable part from memory whose service boundary is a larger device."
                    },
                    {
                        "name": "Storage capacity and organisation",
                        "kind": "measurement",
                        "unit_or_values": "bits or bytes, with addressable location count and bits per location",
                        "why_it_matters": "Allows an agent to interpret addresses and compare memory requirements without confusing capacity with word width."
                    },
                    {
                        "name": "Read interface",
                        "kind": "category",
                        "unit_or_values": "parallel | serial | internal mapped interface | implementation-specific",
                        "why_it_matters": "Determines how a host accesses stored values and what interface evidence is required."
                    },
                    {
                        "name": "Read timing",
                        "kind": "measurement",
                        "unit_or_values": "access time in ns or µs; clock rate in Hz where applicable, with operating conditions",
                        "why_it_matters": "Determines whether the host can obtain valid data within its timing constraints."
                    },
                    {
                        "name": "Electrical operating limits",
                        "kind": "measurement",
                        "unit_or_values": "supply and signal voltages in V; current in A; separate programming conditions where applicable",
                        "why_it_matters": "Prevents incompatible reads or programming attempts and supports power budgeting."
                    },
                    {
                        "name": "Programming and protection state",
                        "kind": "state",
                        "unit_or_values": "blank | programmed | partially programmed | write-protected | permanently locked | unknown; applicability depends on implementation",
                        "why_it_matters": "Constrains permissible operations and identifies irreversible transitions."
                    },
                    {
                        "name": "Retention specification",
                        "kind": "measurement",
                        "unit_or_values": "specified duration in years with temperature and other qualifying conditions",
                        "why_it_matters": "Supports assessment of stored-data longevity without treating nonvolatile storage as permanent."
                    },
                    {
                        "name": "Programming endurance",
                        "kind": "measurement",
                        "unit_or_values": "specified programming or erase cycles; not applicable for non-reprogrammable implementations",
                        "why_it_matters": "Constrains repeated changes where supported and avoids assigning rewrite capability to immutable ROM."
                    },
                    {
                        "name": "Content verification state",
                        "kind": "state",
                        "unit_or_values": "unread | read successfully | matched trusted reference | mismatch | unstable reads | inaccessible",
                        "why_it_matters": "Separates successful electrical access from evidence that the contents are correct."
                    },
                    {
                        "name": "Host and content associations",
                        "kind": "relation",
                        "unit_or_values": "containing device, mapped region, compatible host revisions and referenced content identity",
                        "why_it_matters": "Connects the memory to its intended use without absorbing the host or firmware into this model."
                    }
                ],
                "affordances": [
                    "Classify a device or embedded region by its documented ROM implementation and physical boundary.",
                    "Determine compatible read conditions, addressing and interface settings.",
                    "Read accessible contents and compare them with an authorised, trusted reference.",
                    "Determine whether programming, erasure or protection changes are supported and whether each operation is reversible.",
                    "Assess retention and read-integrity evidence and identify when replacement or further diagnosis is needed.",
                    "Evaluate a proposed replacement against package, interface, timing, content and host compatibility."
                ]
            },
            "sources": [],
            "structure": {
                "bundles": [
                    {
                        "id": "rom-identity-and-boundary",
                        "name": "ROM identity and boundary",
                        "description": "Establishes which physical memory the model describes and what read-only means for that implementation.",
                        "rationale": "The term ROM can refer to immutable silicon, specially programmable memory or a stored image; agents must resolve that ambiguity before acting.",
                        "layers": [
                            {
                                "id": "physical-memory-identity",
                                "name": "Physical memory identity",
                                "description": "Identifies the memory component or embedded region independently of its contents.",
                                "findings": [
                                    {
                                        "id": "component-or-region-boundary",
                                        "name": "Component or region boundary",
                                        "description": "Record whether the ROM is a discrete component or an identifiable region within another device, together with evidence locating it.",
                                        "questions": [
                                            {
                                                "text": "Which physical component or embedded address region is being identified as read-only memory?",
                                                "kind": "boundary",
                                                "id": "component-or-region-boundary-q01"
                                            },
                                            {
                                                "text": "Which marking, device documentation or memory map establishes that identity?",
                                                "kind": "provenance",
                                                "id": "component-or-region-boundary-q02"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "meaning-of-read-only",
                                "name": "Meaning of read-only",
                                "description": "Separates physical immutability from restricted programming and temporary write restrictions.",
                                "findings": [
                                    {
                                        "id": "rom-classification-basis",
                                        "name": "ROM classification basis",
                                        "description": "Record the implementation and the basis for treating it as ROM, including any distinction between normal reads and content-changing operations.",
                                        "questions": [
                                            {
                                                "text": "Does read-only mean contents are fixed at manufacture, programmable once or changeable through a separate procedure?",
                                                "kind": "definition",
                                                "id": "rom-classification-basis-q01"
                                            },
                                            {
                                                "text": "If the storage is EEPROM or flash, what documented role or classification places it within this ROM model?",
                                                "kind": "boundary",
                                                "id": "rom-classification-basis-q02"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "content-establishment-and-mutability",
                        "name": "Content establishment and mutability",
                        "description": "Describes how bits are initially established and whether they can subsequently change.",
                        "rationale": "An agent must distinguish replacement-only ROM from programmable variants before recommending an update or attempting erasure.",
                        "layers": [
                            {
                                "id": "initial-content-establishment",
                                "name": "Initial content establishment",
                                "description": "Captures manufacture-time or later programming and its verification evidence.",
                                "findings": [
                                    {
                                        "id": "programming-origin",
                                        "name": "Programming origin",
                                        "description": "Identify when and by what supported process the contents are established, without assuming every ROM begins as a user-programmable blank.",
                                        "questions": [
                                            {
                                                "text": "Are contents established during manufacture or through a subsequent programming operation?",
                                                "kind": "definition",
                                                "id": "programming-origin-q01"
                                            },
                                            {
                                                "text": "What programming record or manufacturer identifier connects this memory to its intended content revision?",
                                                "kind": "provenance",
                                                "id": "programming-origin-q02"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "permitted-content-transitions",
                                "name": "Permitted content transitions",
                                "description": "Defines supported content changes, erase granularity and irreversible states.",
                                "findings": [
                                    {
                                        "id": "rewrite-and-lock-constraints",
                                        "name": "Rewrite and lock constraints",
                                        "description": "Record whether further programming is possible, whether erasure is required and which protection transitions prevent later changes.",
                                        "questions": [
                                            {
                                                "text": "Which documented procedure, equipment and operating conditions permit programming or erasure, if any?",
                                                "kind": "action",
                                                "id": "rewrite-and-lock-constraints-q01"
                                            },
                                            {
                                                "text": "What is the affected programming or erase unit, and which operations or locks are irreversible?",
                                                "kind": "boundary",
                                                "id": "rewrite-and-lock-constraints-q02"
                                            },
                                            {
                                                "text": "What evidence establishes the present blank, programmed or protected state?",
                                                "kind": "provenance",
                                                "id": "rewrite-and-lock-constraints-q03"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "addressing-and-read-operation",
                        "name": "Addressing and read operation",
                        "description": "Describes how stored locations become valid data at the host interface.",
                        "rationale": "Correct ROM identification is insufficient if an agent reads the wrong addresses, misinterprets organisation or violates interface timing.",
                        "layers": [
                            {
                                "id": "storage-organisation",
                                "name": "Storage organisation",
                                "description": "Captures capacity, location width and the mapping between host requests and stored locations.",
                                "findings": [
                                    {
                                        "id": "address-to-content-mapping",
                                        "name": "Address-to-content mapping",
                                        "description": "Record addressable capacity, word width and any host mapping or banking needed to reconstruct a complete read.",
                                        "questions": [
                                            {
                                                "text": "How many locations are accessible, how many bits does each contain and what capacity does that represent?",
                                                "kind": "measurement",
                                                "id": "address-to-content-mapping-q01"
                                            },
                                            {
                                                "text": "How do host addresses, bank selections or serial commands select the intended stored locations?",
                                                "kind": "definition",
                                                "id": "address-to-content-mapping-q02"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "valid-read-conditions",
                                "name": "Valid read conditions",
                                "description": "Specifies the interface states and operating limits required for reliable reads.",
                                "findings": [
                                    {
                                        "id": "electrical-and-timing-contract",
                                        "name": "Electrical and timing contract",
                                        "description": "Record supply, signalling, selection and timing requirements from documentation applicable to the implementation.",
                                        "questions": [
                                            {
                                                "text": "What supply voltage, signal levels and access timing or clock limits apply under the intended operating conditions?",
                                                "kind": "measurement",
                                                "id": "electrical-and-timing-contract-q01"
                                            },
                                            {
                                                "text": "Which enable signals, commands or host states are required to read without contention or unintended programming?",
                                                "kind": "action",
                                                "id": "electrical-and-timing-contract-q02"
                                            },
                                            {
                                                "text": "Which datasheet or interface specification establishes these requirements for this device revision?",
                                                "kind": "provenance",
                                                "id": "electrical-and-timing-contract-q03"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "retention-and-content-integrity",
                        "name": "Retention and content integrity",
                        "description": "Separates persistence of stored bits, repeatable reads and correspondence with intended contents.",
                        "rationale": "A ROM can return stable but incorrect contents, while an interface fault can make intact storage appear corrupt.",
                        "layers": [
                            {
                                "id": "retention-and-wear",
                                "name": "Retention and wear",
                                "description": "Captures applicable retention conditions and programming-related limits.",
                                "findings": [
                                    {
                                        "id": "qualified-storage-lifetime",
                                        "name": "Qualified storage lifetime",
                                        "description": "Record retention and endurance claims with their conditions and applicability, leaving undocumented lifetime estimates unresolved.",
                                        "questions": [
                                            {
                                                "text": "What retention duration is specified, and under which temperature and usage conditions?",
                                                "kind": "measurement",
                                                "id": "qualified-storage-lifetime-q01"
                                            },
                                            {
                                                "text": "For reprogrammable implementations, what endurance limit and programming history are available?",
                                                "kind": "provenance",
                                                "id": "qualified-storage-lifetime-q02"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "verification-and-diagnosis",
                                "name": "Verification and diagnosis",
                                "description": "Establishes what observations support a conclusion about stored-data integrity.",
                                "findings": [
                                    {
                                        "id": "readback-evidence",
                                        "name": "Readback evidence",
                                        "description": "Distinguish repeatable readback, agreement with a trusted reference and unresolved faults in the memory or read path.",
                                        "questions": [
                                            {
                                                "text": "Do repeated reads under valid operating conditions produce identical data across all accessible locations?",
                                                "kind": "measurement",
                                                "id": "readback-evidence-q01"
                                            },
                                            {
                                                "text": "Which trusted image, digest or manufacturer verification mechanism establishes the expected contents?",
                                                "kind": "provenance",
                                                "id": "readback-evidence-q02"
                                            },
                                            {
                                                "text": "What diagnostic action can distinguish stored-bit errors from addressing, timing, power or connection faults?",
                                                "kind": "action",
                                                "id": "readback-evidence-q03"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "host-integration-and-service",
                        "name": "Host integration and service",
                        "description": "Connects ROM hardware and content identity to compatibility, access restrictions and service decisions.",
                        "rationale": "Matching capacity or package alone does not establish that a ROM can safely replace another or serve the same host function.",
                        "layers": [
                            {
                                "id": "host-and-content-compatibility",
                                "name": "Host and content compatibility",
                                "description": "Records the host relationships needed to assess functional substitution.",
                                "findings": [
                                    {
                                        "id": "replacement-compatibility",
                                        "name": "Replacement compatibility",
                                        "description": "Compare physical and electrical fit, read behaviour and required content revision before treating two ROMs as interchangeable.",
                                        "questions": [
                                            {
                                                "text": "Which package, pinout or embedded interface, capacity and timing requirements must a replacement satisfy?",
                                                "kind": "boundary",
                                                "id": "replacement-compatibility-q01"
                                            },
                                            {
                                                "text": "Which host revisions require which content identity, and what evidence establishes that association?",
                                                "kind": "provenance",
                                                "id": "replacement-compatibility-q02"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "access-and-service-decisions",
                                "name": "Access and service decisions",
                                "description": "Determines whether readout, programming or replacement is feasible for the installed memory.",
                                "findings": [
                                    {
                                        "id": "serviceable-action-boundary",
                                        "name": "Serviceable action boundary",
                                        "description": "Record readout restrictions, hardware protection and the smallest replaceable assembly, separating technical capability from permission to act.",
                                        "questions": [
                                            {
                                                "text": "Can this memory be read or programmed in place, or does access require removal, a service mode or a dedicated programmer?",
                                                "kind": "action",
                                                "id": "serviceable-action-boundary-q01"
                                            },
                                            {
                                                "text": "If contents cannot be changed or verified, which component or containing assembly is the documented replacement boundary?",
                                                "kind": "boundary",
                                                "id": "serviceable-action-boundary-q02"
                                            },
                                            {
                                                "text": "Which protection states and authorisations govern the proposed readout or content-changing operation?",
                                                "kind": "action",
                                                "id": "serviceable-action-boundary-q03"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "evidence-and-external-alignment",
                        "name": "Evidence and external alignment",
                        "description": "What the world already says about this thing, gathered so the model can be checked against it.",
                        "rationale": "A model that cannot be lined up against existing standards, identifiers and practice cannot be adopted by anyone who already uses them.",
                        "layers": [
                            {
                                "id": "reported-evidence",
                                "name": "Reported evidence",
                                "description": "Findings from the breadth pass, kept separate from the structural claims.",
                                "findings": [
                                    {
                                        "id": "evidence-confidence-notes",
                                        "name": "Check these first",
                                        "description": "Recalled without web access and unsourced; every item is a lead to verify.",
                                        "evidence": [
                                            "This describes the semiconductor memory category, not a particular chip, firmware image or colloquial use of ROM to mean device storage.",
                                            "Terminology varies: strict usage reserves ROM for permanently fixed contents, while broader usage includes PROM, EPROM, EEPROM and flash.",
                                            "The measurement ranges are illustrative recall, not verified specifications; retention, access time and capacity require technology-specific datasheets."
                                        ],
                                        "questions": [
                                            {
                                                "id": "evidence-confidence-notes-q01",
                                                "text": "Which of these check these first hold for the sense of read-only memory this model covers, and on what evidence?",
                                                "kind": "provenance"
                                            }
                                        ]
                                    },
                                    {
                                        "id": "evidence-kinds",
                                        "name": "Kinds and varieties",
                                        "description": "Recalled without web access and unsourced; every item is a lead to verify.",
                                        "evidence": [
                                            "Mask ROM, programmed during manufacture",
                                            "Programmable ROM (PROM), programmable once",
                                            "Erasable programmable ROM (EPROM), erased using ultraviolet light",
                                            "Electrically erasable programmable ROM (EEPROM)",
                                            "Flash memory, an electrically erasable form commonly erased in blocks"
                                        ],
                                        "questions": [
                                            {
                                                "id": "evidence-kinds-q01",
                                                "text": "Which of these kinds and varieties hold for the sense of read-only memory this model covers, and on what evidence?",
                                                "kind": "provenance"
                                            }
                                        ]
                                    },
                                    {
                                        "id": "evidence-real-world-use",
                                        "name": "Real-world use",
                                        "description": "Recalled without web access and unsourced; every item is a lead to verify.",
                                        "evidence": [
                                            "Storing boot code and device firmware",
                                            "Holding fixed lookup tables, character generators and control data",
                                            "Distributing software in game cartridges",
                                            "Retaining configuration and calibration data in electrically programmable variants",
                                            "Providing immutable startup or recovery code in embedded processors"
                                        ],
                                        "questions": [
                                            {
                                                "id": "evidence-real-world-use-q01",
                                                "text": "Which of these real-world use hold for the sense of read-only memory this model covers, and on what evidence?",
                                                "kind": "provenance"
                                            }
                                        ]
                                    },
                                    {
                                        "id": "evidence-measurements",
                                        "name": "Typical measurements",
                                        "description": "Recalled without web access and unsourced; every item is a lead to verify.",
                                        "evidence": [
                                            {
                                                "quantity": "Storage capacity in embedded firmware applications",
                                                "typical_range": "A few kilobytes to tens of megabytes, depending on technology and application",
                                                "unit": "byte"
                                            },
                                            {
                                                "quantity": "Parallel ROM read access time",
                                                "typical_range": "Tens to hundreds of nanoseconds for many discrete devices",
                                                "unit": "ns"
                                            },
                                            {
                                                "quantity": "Specified data retention",
                                                "typical_range": "Often 10-20 years for programmable devices under stated operating conditions",
                                                "unit": "year"
                                            }
                                        ],
                                        "questions": [
                                            {
                                                "id": "evidence-measurements-q01",
                                                "text": "Which of these typical measurements hold for the sense of read-only memory this model covers, and on what evidence?",
                                                "kind": "provenance"
                                            }
                                        ]
                                    },
                                    {
                                        "id": "evidence-failure-modes-and-hazards",
                                        "name": "Failure modes and hazards",
                                        "description": "Recalled without web access and unsourced; every item is a lead to verify.",
                                        "evidence": [
                                            "Charge loss in charge-storage variants can corrupt retained bits, particularly with elevated temperature or accumulated wear.",
                                            "EEPROM and flash have finite erase/write endurance; exceeding it can cause programming or retention failures.",
                                            "Power interruption during electrical programming or erasure can leave firmware incomplete or corrupted.",
                                            "Electrostatic discharge, excessive voltage or operation outside temperature limits can damage the device.",
                                            "Errors or vulnerabilities in permanently programmed code can require hardware replacement or an external workaround."
                                        ],
                                        "questions": [
                                            {
                                                "id": "evidence-failure-modes-and-hazards-q01",
                                                "text": "Which of these failure modes and hazards hold for the sense of read-only memory this model covers, and on what evidence?",
                                                "kind": "provenance"
                                            }
                                        ]
                                    },
                                    {
                                        "id": "evidence-neighbours",
                                        "name": "Neighbouring kinds and how to tell them apart",
                                        "description": "Recalled without web access and unsourced; every item is a lead to verify.",
                                        "evidence": [
                                            {
                                                "name": "Random-access memory (RAM)",
                                                "difference": "RAM ordinarily supports routine reads and writes during computation; ROM restricts modification. Random access itself does not distinguish them, because ROM can also support random addressing."
                                            },
                                            {
                                                "name": "Nonvolatile memory",
                                                "difference": "Nonvolatile memory is the broader category of memory that retains data without power; ROM additionally describes fixed or specially programmed contents."
                                            },
                                            {
                                                "name": "Flash memory",
                                                "difference": "Flash is an electrically reprogrammable nonvolatile technology often grouped into the ROM family, but it also serves frequently rewritten storage applications."
                                            },
                                            {
                                                "name": "Firmware",
                                                "difference": "Firmware is the stored program or control information; ROM is one physical medium that can hold it."
                                            },
                                            {
                                                "name": "Read-only storage",
                                                "difference": "Read-only storage includes media and access restrictions beyond semiconductor memory; a writable device made read-only by software is not thereby a ROM device."
                                            }
                                        ],
                                        "questions": [
                                            {
                                                "id": "evidence-neighbours-q01",
                                                "text": "Which of these neighbouring kinds and how to tell them apart hold for the sense of read-only memory this model covers, and on what evidence?",
                                                "kind": "provenance"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            },
            "openQuestions": [
                "Does the registry intend ROM in the narrow immutable sense or the broader family that includes EPROM, EEPROM and flash used as ROM?",
                "Which existing Vercy models cover semiconductor memory, flash memory, firmware and embedded memory regions, and where should this model link to them?",
                "Which manufacturer documents and issuing-body standards should ground implementation-specific interface, programming and qualification requirements?",
                "What sourced retention, endurance, capacity and timing ranges are useful for each ROM implementation without implying universal limits?",
                "Which failure mechanisms and diagnostic procedures are established for each implementation, and what evidence is sufficient to distinguish memory failure from host-interface failure?"
            ],
            "statistics": {
                "bundles": 6,
                "layers": 11,
                "findings": 16,
                "questions": 30
            }
        },
        "draft": {
            "generator": "vr.draft.v3",
            "status": "draft-generated",
            "researched": false,
            "archetype": "device, machine or tool",
            "method": "Written from the archetype playbook - what this kind of thing needs beyond identity and provenance - and from the structure that recurred across 6,333 models already researched by two engines. Applied to this entry by rule. No source was read for this thing and no claim here is researched. This entry carries no facets of its own, so they were inferred from its domain - a guess about a whole domain applied to one thing.",
            "facetsInferred": true,
            "nextPass": "A researcher replaces this draft with a sourced specification. Treat every sentence below as a proposal to argue with.",
            "purpose": "Give an agent a durable, checkable way to recognise a read-only memory, record what state it is in, and decide what may be done with it.",
            "whatItIs": "Enable an AI agent to recognise read-only memory, assess whether its stored contents can be read reliably, and determine which programming, replacement or protection actions its implementation permits.",
            "characteristics": {
                "substance": "material",
                "origin": "manufactured",
                "agency": "inert",
                "mobility": "varies"
            },
            "whatYouCanDoWithIt": [
                "observed and measured"
            ],
            "distinguishingFeatures": [
                "Names folded into this entry, which a task may need to split apart again: functional cathode ray tube, Nintendo optical disc, Nintendo GameCube Disc, Nintendo Wii Disc, Nintendo Wii U Disc, mask read-only memory, Kanji-ROM, 556 series integrated circuits, Boot ROM, core rope memory, TMS6100, 596 series integrated circuits.",
                "12 finer distinctions are held as aliases rather than separate entries, because telling them apart needs a task that asks for it.",
                "Described in 77 Wikipedia languages, which is a measure of how widely the thing is known, not of how important it is."
            ],
            "openQuestionsForResearch": [
                "Which of the bundles below does a real task actually need, and which are ceremony?",
                "What does this thing have that the facets do not capture at all?",
                "Which neighbouring kind is most often confused with a read-only memory, and on what evidence are they told apart?"
            ],
            "whatItIsMadeOf": "matter you can touch",
            "physicalCharacter": [
                "Mobility varies between examples.",
                "Does nothing on its own; everything it does, something else did to it.",
                "These come from the domain this entry sits in rather than from the entry itself, so treat them as a first guess about the whole domain applied to one thing."
            ],
            "whatCanBeDoneWithIt": [
                "observe it, measure it, record its state"
            ],
            "howItIsRecognised": [
                "Recognised by form, by the arrangement of its controls, and by markings - a plate, a model number, a certification mark. Form alone rarely separates two models that do very different things."
            ],
            "relatedModels": [
                {
                    "relation": "covers",
                    "note": "Finer kinds folded into this entry because telling them apart needs a task that asks for it. Each is a model waiting to be split out when one does.",
                    "targets": [
                        "functional cathode ray tube",
                        "Nintendo optical disc",
                        "Nintendo GameCube Disc",
                        "Nintendo Wii Disc",
                        "Nintendo Wii U Disc",
                        "mask read-only memory",
                        "Kanji-ROM",
                        "556 series integrated circuits",
                        "Boot ROM",
                        "core rope memory",
                        "TMS6100",
                        "596 series integrated circuits"
                    ]
                }
            ],
            "standing": "Described in 77 Wikipedia languages, which measures how widely it is written about rather than how important or how common it is. 12 finer distinctions are held inside this entry as names rather than as separate models.",
            "structure": {
                "bundles": [
                    {
                        "id": "identity-and-classification",
                        "name": "Identity, naming and classification",
                        "description": "How an agent tells one read-only memory from another, and a read-only memory from things that resemble it.",
                        "rationale": "Recognition comes before every other claim. Without stable identity nothing else in the model can be trusted to be about the same thing twice.",
                        "layers": [
                            {
                                "id": "naming-and-identifiers",
                                "name": "Names and identifiers",
                                "description": "The names this thing goes by and the identifiers that survive translation and time.",
                                "findings": [
                                    {
                                        "id": "preferred-name-and-aliases",
                                        "name": "Preferred name, aliases and local names",
                                        "description": "Which name to use, which names mean the same thing, and which merely sound similar.",
                                        "questions": [
                                            {
                                                "id": "preferred-name-and-aliases-q01",
                                                "text": "What identifies and describes the name of a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "preferred-name-and-aliases-q02",
                                                "text": "Who or what asserted this about the name of a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "preferred-name-and-aliases-q03",
                                                "text": "What may an agent decide or do once the name of a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    },
                                    {
                                        "id": "stable-identifiers",
                                        "name": "Stable identifiers and external keys",
                                        "description": "Identifiers that keep pointing at this kind of thing across systems and languages.",
                                        "questions": [
                                            {
                                                "id": "stable-identifiers-q01",
                                                "text": "What identifies and describes an identifier for a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "stable-identifiers-q02",
                                                "text": "Who or what asserted this about an identifier for a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "stable-identifiers-q03",
                                                "text": "What may an agent decide or do once an identifier for a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "classification-and-granularity",
                                "name": "Classification and granularity",
                                "description": "Where a read-only memory sits among kinds, and how finely a task needs to cut it.",
                                "findings": [
                                    {
                                        "id": "kind-and-parents",
                                        "name": "Kind, parents and neighbouring kinds",
                                        "description": "The classes this thing belongs to and the ones it is next to.",
                                        "questions": [
                                            {
                                                "id": "kind-and-parents-q01",
                                                "text": "What identifies and describes the kind of a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "kind-and-parents-q02",
                                                "text": "Who or what asserted this about the kind of a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "kind-and-parents-q03",
                                                "text": "What may an agent decide or do once the kind of a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    },
                                    {
                                        "id": "distinguishing-features",
                                        "name": "Distinguishing features",
                                        "description": "What separates a read-only memory from the things most often confused with it.",
                                        "questions": [
                                            {
                                                "id": "distinguishing-features-q01",
                                                "text": "What identifies and describes what distinguishes a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "distinguishing-features-q02",
                                                "text": "Who or what asserted this about what distinguishes a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "distinguishing-features-q03",
                                                "text": "What may an agent decide or do once what distinguishes a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "form-and-composition",
                        "name": "Form, composition and condition",
                        "description": "What a read-only memory is made of, what shape and size it takes, and what state it is in.",
                        "rationale": "A physical thing can be measured, and a model that cannot record its measurements cannot support any decision that depends on them.",
                        "layers": [
                            {
                                "id": "form-and-dimensions",
                                "name": "Form and dimensions",
                                "description": "Shape, size, mass and the ranges these take across examples.",
                                "findings": [
                                    {
                                        "id": "measurable-dimensions",
                                        "name": "Measurable dimensions and their units",
                                        "description": "The quantities worth recording and the units they are recorded in.",
                                        "questions": [
                                            {
                                                "id": "measurable-dimensions-q01",
                                                "text": "What identifies and describes the dimensions of a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "measurable-dimensions-q02",
                                                "text": "Who or what asserted this about the dimensions of a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "measurable-dimensions-q03",
                                                "text": "What may an agent decide or do once the dimensions of a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "material-and-composition",
                                "name": "Material and composition",
                                "description": "Materials, parts and how they are put together.",
                                "findings": [
                                    {
                                        "id": "parts-and-materials",
                                        "name": "Parts and materials",
                                        "description": "What a read-only memory is built from and which parts are replaceable.",
                                        "questions": [
                                            {
                                                "id": "parts-and-materials-q01",
                                                "text": "What identifies and describes the composition of a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "parts-and-materials-q02",
                                                "text": "Who or what asserted this about the composition of a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "parts-and-materials-q03",
                                                "text": "What may an agent decide or do once the composition of a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "condition-and-integrity",
                                "name": "Condition and integrity",
                                "description": "Wear, damage, health and the difference between working and broken.",
                                "findings": [
                                    {
                                        "id": "condition-assessment",
                                        "name": "Condition, damage and health",
                                        "description": "How the condition of a read-only memory is judged and by whom.",
                                        "questions": [
                                            {
                                                "id": "condition-assessment-q01",
                                                "text": "What identifies and describes the condition of a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "condition-assessment-q02",
                                                "text": "Who or what asserted this about the condition of a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "condition-assessment-q03",
                                                "text": "What may an agent decide or do once the condition of a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "place-and-movement",
                        "name": "Place and movement",
                        "description": "Where a read-only memory is, how it got there and where it may go (varies).",
                        "rationale": "A thing that can move needs its position recorded with a time, or every later claim about it is about a place it has left.",
                        "layers": [
                            {
                                "id": "location-and-placement",
                                "name": "Location and placement",
                                "description": "Position, containment and the reference frame the position is given in.",
                                "findings": [
                                    {
                                        "id": "position-and-frame",
                                        "name": "Position, container and reference frame",
                                        "description": "Where a read-only memory is, and what that position is measured against.",
                                        "questions": [
                                            {
                                                "id": "position-and-frame-q01",
                                                "text": "What identifies and describes the location of a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "position-and-frame-q02",
                                                "text": "Who or what asserted this about the location of a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "position-and-frame-q03",
                                                "text": "What may an agent decide or do once the location of a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "movement-and-transfer",
                                "name": "Movement and transfer",
                                "description": "How a read-only memory is carried, installed or relocated.",
                                "findings": [
                                    {
                                        "id": "movement-events",
                                        "name": "Movement events and constraints",
                                        "description": "What counts as a movement, what records it and what limits it.",
                                        "questions": [
                                            {
                                                "id": "movement-events-q01",
                                                "text": "What identifies and describes the movement of a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "movement-events-q02",
                                                "text": "Who or what asserted this about the movement of a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "movement-events-q03",
                                                "text": "What may an agent decide or do once the movement of a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "state-and-lifecycle",
                        "name": "State and lifecycle",
                        "description": "The states a read-only memory passes through and the events that move it between them.",
                        "rationale": "Most decisions about a thing depend on what state it is in now, which is a claim with a time on it, not a property.",
                        "layers": [
                            {
                                "id": "lifecycle-stages",
                                "name": "Lifecycle stages",
                                "description": "From coming into existence to ceasing to be one of these.",
                                "findings": [
                                    {
                                        "id": "stages-and-transitions",
                                        "name": "Stages and transitions",
                                        "description": "The stages worth naming and what moves a read-only memory between them.",
                                        "questions": [
                                            {
                                                "id": "stages-and-transitions-q01",
                                                "text": "What identifies and describes the lifecycle of a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "stages-and-transitions-q02",
                                                "text": "Who or what asserted this about the lifecycle of a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "stages-and-transitions-q03",
                                                "text": "What may an agent decide or do once the lifecycle of a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "observations-and-status",
                                "name": "Observations and current status",
                                "description": "What is observed about a read-only memory, how often and by whom.",
                                "findings": [
                                    {
                                        "id": "observation-record",
                                        "name": "Observation record",
                                        "description": "How an observation of a read-only memory is recorded so that it can be superseded rather than overwritten.",
                                        "questions": [
                                            {
                                                "id": "observation-record-q01",
                                                "text": "What identifies and describes an observation of a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "observation-record-q02",
                                                "text": "Who or what asserted this about an observation of a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "observation-record-q03",
                                                "text": "What may an agent decide or do once an observation of a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "function-and-principle",
                        "name": "Function and operating principle",
                        "description": "What read-only memory is for and how it achieves it.",
                        "rationale": "Two devices with the same name can work on different principles, and the principle is what predicts failure and constrains use.",
                        "layers": [
                            {
                                "id": "intended-function",
                                "name": "Intended function",
                                "description": "The job it does, and the jobs it is used for anyway.",
                                "findings": [
                                    {
                                        "id": "function-record",
                                        "name": "Function, principle and variants",
                                        "description": "What it does, how, and which variants do it differently.",
                                        "questions": [
                                            {
                                                "id": "function-record-q01",
                                                "text": "What function does read-only memory perform, on what operating principle, and which variants differ in that principle?",
                                                "kind": "definition"
                                            },
                                            {
                                                "id": "function-record-q02",
                                                "text": "What use falls outside the intended function but happens in practice?",
                                                "kind": "boundary"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "capacity-and-rating",
                                "name": "Capacity and rating",
                                "description": "The numbers that say what it can do and where it stops.",
                                "findings": [
                                    {
                                        "id": "ratings",
                                        "name": "Ratings and their conditions",
                                        "description": "Rated capacity, power, throughput and the conditions each assumes.",
                                        "questions": [
                                            {
                                                "id": "ratings-q01",
                                                "text": "What ratings characterise read-only memory, in what units, and under what stated conditions?",
                                                "kind": "measurement"
                                            },
                                            {
                                                "id": "ratings-q02",
                                                "text": "What happens beyond the rating - degradation, refusal, damage - and how is that detected?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "operation-and-state",
                        "name": "Operation, controls and state",
                        "description": "How read-only memory is operated and what state it is in right now.",
                        "rationale": "An agent acting on a device needs its current state and the controls that change it, not just its specification.",
                        "layers": [
                            {
                                "id": "controls-and-modes",
                                "name": "Controls and modes",
                                "description": "What can be set, what that changes, and what is interlocked.",
                                "findings": [
                                    {
                                        "id": "control-surface",
                                        "name": "Control surface and interlocks",
                                        "description": "The settings available and the conditions that block them.",
                                        "questions": [
                                            {
                                                "id": "control-surface-q01",
                                                "text": "What controls and modes does read-only memory have, and what does each change?",
                                                "kind": "definition"
                                            },
                                            {
                                                "id": "control-surface-q02",
                                                "text": "Which actions are interlocked or forbidden in which state, and what must be true before acting?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "condition-and-maintenance",
                                "name": "Condition and maintenance",
                                "description": "Wear, service intervals, consumables and the line between working and broken.",
                                "findings": [
                                    {
                                        "id": "service-record",
                                        "name": "Condition, service and consumables",
                                        "description": "What is consumed, what is serviced, and how condition is judged.",
                                        "questions": [
                                            {
                                                "id": "service-record-q01",
                                                "text": "What consumables and service does read-only memory need, at what interval, and on whose authority?",
                                                "kind": "measurement"
                                            },
                                            {
                                                "id": "service-record-q02",
                                                "text": "What evidence separates a unit that is working from one that is out of service?",
                                                "kind": "boundary"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "kind-model-unit",
                        "name": "Kind, model and unit",
                        "description": "Whether a claim about read-only memory is about the kind, a product line, or one physical unit.",
                        "rationale": "This is the boundary most often got wrong for made things, and getting it wrong mixes a catalogue entry with the machine in the yard.",
                        "layers": [
                            {
                                "id": "level-of-reference",
                                "name": "Level of reference",
                                "description": "The three levels and what belongs at each.",
                                "findings": [
                                    {
                                        "id": "level-rules",
                                        "name": "What belongs to kind, model and unit",
                                        "description": "Which properties are shared by all of them and which are not.",
                                        "questions": [
                                            {
                                                "id": "level-rules-q01",
                                                "text": "Which facts about read-only memory hold for every one of them, which for a model, and which only for one unit?",
                                                "kind": "boundary"
                                            },
                                            {
                                                "id": "level-rules-q02",
                                                "text": "What identifies an individual unit, and what should an agent do when it has only the kind?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "standards-and-conformity",
                                "name": "Standards and conformity",
                                "description": "The standards a working example must meet and who attests it.",
                                "findings": [
                                    {
                                        "id": "conformity",
                                        "name": "Standards, marks and attestation",
                                        "description": "Which standard applies, who certifies, and what the mark means.",
                                        "questions": [
                                            {
                                                "id": "conformity-q01",
                                                "text": "Which standards govern read-only memory, issued by whom, and what does conformity actually assert?",
                                                "kind": "provenance"
                                            },
                                            {
                                                "id": "conformity-q02",
                                                "text": "What may an agent conclude from a certification mark, and what may it not?",
                                                "kind": "boundary"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "provenance-and-evidence",
                        "name": "Provenance, evidence and time",
                        "description": "Where every claim about a read-only memory came from and when it held.",
                        "rationale": "A claim without a source and a time cannot be superseded, only overwritten, and an agent that overwrites loses the ability to explain itself.",
                        "layers": [
                            {
                                "id": "source-and-authority",
                                "name": "Source and authority",
                                "description": "Who said it, on what evidence, and how strongly.",
                                "findings": [
                                    {
                                        "id": "claim-provenance",
                                        "name": "Claim provenance and confidence",
                                        "description": "The authority behind each claim about a read-only memory and how confident it is.",
                                        "questions": [
                                            {
                                                "id": "claim-provenance-q01",
                                                "text": "What identifies and describes a claim about a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "claim-provenance-q02",
                                                "text": "Who or what asserted this about a claim about a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "claim-provenance-q03",
                                                "text": "What may an agent decide or do once a claim about a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "time-and-versions",
                                "name": "Time, versions and supersession",
                                "description": "When a claim was true, when it was learnt, and what replaced it.",
                                "findings": [
                                    {
                                        "id": "validity-and-supersession",
                                        "name": "Validity period and supersession",
                                        "description": "How an old claim about a read-only memory is retired without being erased.",
                                        "questions": [
                                            {
                                                "id": "validity-and-supersession-q01",
                                                "text": "What identifies and describes the validity of a claim about a read-only memory, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "validity-and-supersession-q02",
                                                "text": "Who or what asserted this about the validity of a claim about a read-only memory, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "validity-and-supersession-q03",
                                                "text": "What may an agent decide or do once the validity of a claim about a read-only memory is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            },
            "statistics": {
                "bundles": 8,
                "layers": 17,
                "findings": 19,
                "questions": 51
            }
        }
    }
}