Lisp Listeners and editable input reimplementation specification

Release profiles

C303-SRC and C303-RUN are triangulated evidence, not a proven build chain: no record presently establishes that the runnable band was compiled byte-for-byte from the pinned maintained check-in. Likewise, G85-S452.22 and G85-BASE-WORLD belong to the inspected release set, but media presence does not prove that every inspected source body or patch is resident in that world. Requirements identify which witness supports them rather than silently treating these artifacts as identical.

Conformance levels

This specification normatively defines C46/L1, C303/L2, and G85/L2 at the stated semantic grain. The C46 contract is source-grounded; C303 and G85 add only the bounded runtime observations named below. None of those levels is claimed as completely verified against a preserved-system oracle until its open conformance tests and closure probes have run. L3 is reserved.

Normative evidence map and selected-module coverage

Line spans name the inspected artifact versions in the identity table below; they are locators, not reproduced proprietary text.

Every normative section below is governed by one or more rows in this map. Rules marked INF are deliberately portable reconstruction/safety requirements rather than claims about an uninspected historical branch.

Listener

Each evaluation frame records its submitted form or special control action, state, stream/input context, history environment, enclosing frame, and completion kind (values, resume, return, abort, or condition). An implementation MAY use the host language's call stack, but the resulting nesting and recovery MUST remain observable as specified.

Editable input

EditableInput {
  text or character sequence
  point
  optional mark
  activation and pass-through sets
  numeric argument
  local input history
  kill/yank state
  prompt and redisplay state
  active input context
}

C46 and C303 MAY represent the buffer using the historical rubout-handler leaders and replay pointers, but conformance depends on behavior, not that layout. G85 MAY construct temporary Zwei-compatible syntax objects for structural commands; it MUST NOT expose the current input as an ordinary persistent Zmacs buffer.

Genera command transaction

Invariants

1. Two live Listeners MUST be able to wait or evaluate independently.
2. Within one Listener, at most one evaluation frame executes at a time; entering a break suspends rather than replaces its enclosing frame.
3. Selection, visibility, and evaluation/busy state MUST NOT be collapsed.
4. A submitted form becomes the current-form history before its evaluation result is committed to value history.
5. Every returned value, including multiple values, MUST be preserved for history before the next successful evaluation overwrites the newest entry.
6. Editing mutations MUST NOT enter Lisp form history until the reader successfully returns a form. Ordinary CADR input may complete through self-delimiting syntax or terminating whitespace; explicit activation is an additional profile/member mechanism, not the universal commit event.
7. Aborting or failing an evaluation MUST leave a recoverable top-level or debugger path; it MUST NOT silently kill every other Listener.
8. G85 command and Lisp input MUST remain distinguishable even when their printed spelling overlaps.
9. A displayed screenshot MAY constrain visible layout, but MUST NOT be used to infer the process, history, cache, or dispatch state not visible in it.
10. Refreshing or scrolling the display MUST NOT mutate the logical editable-input sequence. This is a source-grounded state invariant with a runtime oracle, not a fact inferred from a still image.

Create or select a Listener

1. Resolve a selection request against live registered/selectable Listener instances.
2. If the operation is selection-only and a suitable instance exists, select or cycle it without creating another.
3. If creation is explicitly requested, allocate the Listener, stream, editor state, and process preset before exposing it for input.
4. Initialize reader and standard-value state according to the profile.
5. Make the window selectable only after its top-level entry path is valid.
6. On partial failure, remove the incomplete registry/window entry and release its process and stream resources. INF

C303 MUST distinguish the internal Listener mixin and LISP-INTERACTOR from a public LISP-LISTENER-P instance. G85 MUST support a Dynamic Windows interactor that can be selected as Lisp; the exact historical class composition is an L3 concern.

Deselect, reset, restart, or kill

• Selecting another activity or burying/deselecting a Listener leaves its process, stream, histories, and identity live unless a separate reset/kill operation occurs.
• Reset MUST abort or reset the target interaction process and return the same live Listener identity to a top-level-ready state. It MUST NOT silently create a replacement or retain an executing evaluation frame. Exact partial input retention is profile-specific runtime evidence.
• A restart after reset MUST reestablish stream bindings, reader/standard values, and one top-level frame before marking the Listener idle/selectable.
• Kill is terminal for that Listener identity. It MUST remove selection/activity registry references, terminate or detach its top-level process, release editor and stream resources, and make later state queries reject it. INF supplies the no-dangling-resource rule where a historical partial-failure branch is untested.
• Killing the last ordinary CADR Listener does not itself create another. A subsequent System L request follows the create-if-none rule above; explicit Genera activity selection likewise resolves reuse before its creation path.

System 303 editing-Listener embodiments

System 303 also exposes two ZWEI-backed Lisp interaction paths. They share the read/evaluate/print contract above, but they MUST NOT be represented as ordinary TV Lisp Listener windows or as aliases for one another:

• ZDT creates the singleton EDITOR-TOP-LEVEL window when absent. Its default argument selects when invoked outside an editor top level and deselects when invoked from one; an explicit argument controls the same transition. Its system-key registration is Top-L, visibly labeled LISP(Edit). Its editing behavior comes from the generic editor-stream command table and its eight-entry overlay, not a separate fixed ZDT keymap. Reader output is inserted through the same editor stream at its stream position and advances the stream end before the next input.
• ZTOP is a Zmacs-buffer major mode. It installs pre-command and post-command hooks, a local editable-input history, and an eight-entry local table. The Zmacs stack group edits the buffer while a dedicated coroutine stack group runs LISP-TOP-LEVEL1 over that buffer's stream. Output is inserted into the buffer at the stream end; an optional ZTOP printer may grind values and prefix output lines, but those options MUST be selected explicitly rather than assumed as universal defaults. Package changes propagate between the editor/buffer and evaluation stack group when control crosses between them.

The ZTOP mode-state transition is normative: entry at buffer end is Reading Input; moving/editing away from stream end enters Editing; if Require Activation is enabled, such editing sets the activation-needed state and the mode line requests End; an eligible self-insert, Return insertion, full rubout, mode entry, or explicit ZTOP activation at stream end returns to Reading Input. Only one of the three state flags may be true.

For both embodiments, eligible input at the end of the editor stream MAY submit automatically. Once point is moved away from the end, a Require Activation mode MUST be able to defer submission until an activation command. In ZTOP, End and Control-Return finish evaluation; Abort and Meta-Abort provide the local and all-level abort paths; Control-Meta-Y yanks input history. The complete binding inventory remains normative in the editor-stream overlay and ZTOP local table. Local abort invokes the error system's stack-group abort on the ZTOP evaluation group; all-level abort applies the normal Meta-Abort path inside that group. If either causes an abnormal coroutine return, the stream re-presets and restarts its ZTOP top level before accepting another form; the surrounding Zmacs buffer/editor remains live.

Submit Lisp input

reader returns one form from editable input
  -> apply the selected profile's form-history commit phase
  -> bind the current form
  -> evaluate in the Listener process
  -> collect all returned values
  -> apply the selected profile's value-history commit phase
  -> print each value on a fresh output line
  -> return to editable input

Reader return, evaluation, and printing are distinct commit boundaries. In this table, f is the newly read form, v is its complete multiple-value list, H is (+, ++, +++), P is (*, **, ***), and V is (//, ////, //////) where that profile has those variables.

These are historical partial effects, not an atomic REPL abstraction. In G85, while f is evaluating, - already denotes f while // still denotes the preceding all-values list. In C303, *VALUES* begins with an initial NIL entry and also gains NIL when evaluation unwinds before producing values. Printer faults occur after value commit in all three inspected loops and MUST NOT roll those histories back.

Enter and leave a nested break

1. Suspend the current evaluation frame and push a break frame in the same Listener process.
2. Establish a fresh input-editing catch/context for the break while preserving the selected profile's relationship to the enclosing stream state.
3. Reuse the enclosing recent-form and value-history environment. Forms evaluated in the break therefore participate in those histories rather than creating an unrelated Listener history.
4. On Resume, pop the break frame and continue the suspended computation.
5. On (RETURN value), pop the break frame and return the evaluated value from the break call to its suspended caller.
6. On Abort, unwind the break and user computation to the owning command/top-level recovery boundary; do not treat the aborted input as a successful value result.

The editable-input boundary differs by profile:

• C46 establishes a new rubout-handler level and clears the old stream's input on exit when the stream supports that operation. It MUST NOT be claimed to restore an interrupted input buffer.
• C303 saves the enclosing rubout-handler buffer and position, establishes a fresh break handler, then restores and redisplays the saved buffer before returning.
• G85 clears the inherited Input Editor typein/options and presentation input context for the break. When the terminal supports its saved-state-for-break operation, it MUST wrap the nested loop in that operation. Exact state on a stream without that operation remains an open runtime branch.

Edit and rescan input

1. Apply movement, insertion, deletion, mark, kill/yank, or history operation to the current editable input.
2. Maintain point and mark within the current logical buffer, except for explicitly source-visible transient states.
3. Rescan the resulting sequence as the profile's reader consumes characters. A self-delimiting form or terminating syntax/whitespace MAY complete ordinary CADR input without a separate activation command.
4. Where the selected handler or editing-Listener embodiment defines explicit activation, End, Control-Return, or the named activation operation MUST force the corresponding reader return/rescan path.
5. If parsing is incomplete, retain the buffer and continue input.
6. If parsing fails through an editor-recoverable error, report it, retain the prompt and editable text, and require an edit/rescan before retry.
7. Commit a form only when the reader successfully returns it.

C303 MUST provide both its standard RH behavior and an explicitly selectable fallback-handler profile if it claims that release's handler-switching facility.

Dispatch Genera command or form

The four source-defined modes are separate parser contracts:

For a nonblank transaction:

1. Select the sole-type parser or combined parser from the matrix above.
2. Only in a mixed preferred mode, apply a leading comma/colon override before the preference rule.
3. Parse a command name or Lisp form without interning speculative completion symbols merely to display candidates.
4. Request command arguments through their typed input contexts.
5. Allow an applicable displayed presentation to supply an argument.
6. Execute the resulting command object or Lisp form.
7. Record output presentations and return to the same Listener unless the command deliberately selects another activity.

At the accept-operation boundary, the selected blank-line mode MUST implement one of five outcomes: Reprompt starts another prompt transaction, Beep signals and keeps reading, Ignore consumes blank activations, Return NIL returns two NIL values, and End Returns NIL reprompts on Return but returns two NIL values on End. The default is Reprompt. In the ordinary Genera Lisp command loop, a returned (NIL, NIL) is then treated as the Lisp form NIL with no special read-type flags: it is evaluated, updates form/value history, and prints NIL. A lower-level caller of the accept operation MAY instead consume those return values itself.

Execute commands and enable or disable the Command Processor

A command wrapper captures every incidental body value in the dynamically current binding of the special *LAST-COMMAND-VALUES*. EXECUTE-COMMAND-INTERNAL establishes a dynamic binding initialized from the surrounding value and returns the captured list; a direct generated command wrapper sets whichever binding is current. The selected source does not establish a stream-local default binding, so a strict implementation MUST NOT claim per-Listener isolation without separate evidence. If the command declaration requests visible values, the wrapper returns the captured list as multiple values to the Listener. Otherwise it returns zero values, so the Listener commits an empty value list and prints no body value even though the current *LAST-COMMAND-VALUES* binding retains it. A reimplementation MUST NOT print every command body's incidental return merely because Lisp evaluation would.

Turning the Command Processor on replaces all six actual hooks: ordinary and break-loop read, evaluate, and print functions. It also sets the selected dispatch mode and prompt; an explicitly supplied prompt updates that mode's prompt-table entry. Turning it off replaces the same six hooks with the Lisp-only defaults, but deliberately leaves the dispatch mode, current prompt, and prompt table unchanged. It is therefore not the general inverse of turning it on. Exact restoration of arbitrary prior state requires capturing the six hooks, mode, prompt, and a copy of the prompt table before the transition, as the historical undo operation does. A hook state can be custom or mixed; enabled and Lisp-only are derived equality tests over the six-value vector, not an exhaustive two-state representation.

Ambiguous completion MUST remain unresolved or display candidates; it MUST NOT choose an arbitrary command merely to make progress.

LM-3 System 303 Listener

Runtime observation: System 303-0, session core-env-20260718, generation 1, after evaluating the researcher-entered form (values 7 8), captured 2026-07-18. The visible contract is a full-screen monochrome text stream, a block input cursor, a Listener identification line, pointer documentation, and the who line beneath the stream. Evaluation input and each returned value occupy successive text lines. The boot text is incidental state, not required application chrome. Underlying software and display material remain the property of their respective rightsholders; reproduced here for criticism, scholarship, and historical documentation under 17 U.S.C. section 107 and the image-specific review in the CADR screenshot catalog. No affiliation or endorsement is implied.

Genera 8.5 Dynamic Lisp Listener

Runtime observation: Genera 8.5, System 452.22 under Open Genera 2.0, session core-dossiers-20260718, generation 1, after evaluating the researcher-entered form (values 17 23), captured 2026-07-18. The visible contract is a bordered Dynamic Windows interactor with vertical and horizontal scrolling affordances, an activity title, Command Processor prompt, text cursor, and separate who line. The large startup heading and unconfigured-site notice are world state, not required for every Listener. Underlying software and display material remain the property of their respective rightsholders; reproduced here for criticism, scholarship, and historical documentation under 17 U.S.C. section 107 and the image-specific review in the Genera screenshot catalog. No affiliation or endorsement is implied.

For both profiles, the current input MUST be visually distinguishable from prior typeout and the insertion point MUST be visible when awaiting input. In G85, Form Only and Form Preferred use the source-defined empty prompt, while Command Preferred and Command Only use Command:; the reviewed frame directly confirms that prompt only for the exercised Command Preferred state. A host implementation MAY add outer desktop decoration if it does not obscure or change the Listener's semantic regions.

Runtime closure probes