@fluado/enmetu 0.0.0-stage → 0.2.0

package/dist/contracts/IHookInstaller.d.ts

@@ -0,0 +1,14 @@
+export type HookSkipReason = 'HOOKS_PATH_SET' | 'FOREIGN_HOOK';
+export type HookInstallResult = {
+    readonly kind: 'installed' | 'updated' | 'unchanged' | 'disabled';
+} | {
+    readonly kind: 'skipped';
+    readonly reason: HookSkipReason;
+    readonly instruction: string;
+} | {
+    readonly kind: 'failed';
+    readonly detail: string;
+};
+export interface IHookInstaller {
+    ensure(): Promise<HookInstallResult>;
+}

package/dist/contracts/IHookInstaller.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/IInstanceLock.d.ts

@@ -0,0 +1,26 @@
+export interface LockHolder {
+    readonly pid: number;
+    /** Informational; the state directory is assumed to be on a local disk. */
+    readonly hostname: string;
+    readonly startedAt: string;
+}
+export type LockAcquisition = {
+    readonly kind: 'acquired';
+    readonly tookOverStale: boolean;
+} | {
+    readonly kind: 'held';
+    readonly holder: LockHolder;
+} | {
+    readonly kind: 'unreadable';
+    readonly path: string;
+};
+/** The read half of the lock, all that status and the library need (design 12.1, 12.5). */
+export interface ILockInspector {
+    /** The live holder, or null when none (a holder whose pid is dead is no holder). */
+    inspect(): Promise<LockHolder | null>;
+}
+export interface IInstanceLock extends ILockInspector {
+    acquire(): Promise<LockAcquisition>;
+    /** Removes the lock only if it carries the token this instance wrote at acquire. */
+    release(): Promise<void>;
+}

package/dist/contracts/IInstanceLock.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/ILogger.d.ts

@@ -0,0 +1,11 @@
+import type { LogCode } from './logCodes.js';
+export type LogLevel = 'INFO' | 'WARN' | 'ERROR';
+export interface LogEntry {
+    readonly level: LogLevel;
+    readonly code: LogCode;
+    readonly message: string;
+    readonly cycleId?: string | undefined;
+}
+export interface ILogger {
+    log(entry: LogEntry): void;
+}

package/dist/contracts/ILogger.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/IOperationJournal.d.ts

@@ -0,0 +1,12 @@
+export interface RebaseJournal {
+    readonly origHead: string;
+    readonly onto: string;
+    readonly cycleId: string;
+    readonly at: string;
+}
+export interface IOperationJournal {
+    /** An unparseable journal gives null. */
+    read(): Promise<RebaseJournal | null>;
+    begin(entry: RebaseJournal): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/contracts/IOperationJournal.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/IPathQuarantine.d.ts

@@ -0,0 +1,67 @@
+export interface QuarantineEntry {
+    readonly path: string;
+    /** null: the path was deleted in the working tree. */
+    readonly blobId: string | null;
+    readonly executable: boolean;
+    /**
+     * The index's blob for the path when the hold checked it out, which is what
+     * the checkout wrote into the working tree; null when the index had no
+     * stage-0 entry, or for a memento written before the field existed.
+     */
+    readonly heldOver: string | null;
+}
+export interface QuarantineMemento {
+    readonly version: 1;
+    readonly entries: readonly QuarantineEntry[];
+}
+export interface KeptBlob {
+    readonly path: string;
+    readonly blobId: string;
+}
+export type HoldResult = {
+    readonly kind: 'held';
+    readonly count: number;
+} | {
+    readonly kind: 'unsupported';
+    readonly path: string;
+}
+/** A memento from an earlier hold is still pending; nothing was touched. */
+ | {
+    readonly kind: 'pending';
+};
+export type RestoreResult = {
+    readonly kind: 'nothing';
+} | {
+    readonly kind: 'restored';
+    readonly count: number;
+    readonly kept: readonly KeptBlob[];
+    /**
+     * Paths whose held version went back although HEAD's version changed
+     * while they were held (a rebase pulled a change) and the two did not
+     * merge cleanly: committing them undoes that change (Decision 99).
+     */
+    readonly changedUnderHold: readonly string[];
+    /**
+     * A write that landed on a file after the restore's last check of it and
+     * before its own write, which the held (or merged) version replaced; the
+     * replaced bytes are kept in a blob (design 13.11, Decision 117).
+     */
+    readonly overwritten: readonly KeptBlob[];
+} | {
+    readonly kind: 'failed';
+    readonly detail: string;
+};
+export interface IPathQuarantine {
+    /** Persists the memento before touching the tree; tracked worktree changes only; refuses while a memento is pending. */
+    hold(paths: readonly string[]): Promise<HoldResult>;
+    /**
+     * Captures writes that landed while enmetu's rebase was stopped, before the abort
+     * resets them (Decision 45): stores the blobs, appends to a pending memento or
+     * creates one, then restores the paths from the index. A later entry for a path
+     * supersedes an earlier one at restore. An unparseable memento returns pending
+     * and nothing is touched.
+     */
+    extend(paths: readonly string[]): Promise<HoldResult>;
+    restore(): Promise<RestoreResult>;
+    hasPending(): Promise<boolean>;
+}

package/dist/contracts/IPathQuarantine.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/IProcessHost.d.ts

@@ -0,0 +1,11 @@
+export type StopSignal = 'SIGINT' | 'SIGTERM' | 'SIGHUP';
+export interface IProcessHost {
+    readonly pid: number;
+    /** Informational only (lock file, status); liveness is judged by pid. */
+    readonly hostname: string;
+    isAlive(pid: number): boolean;
+    /** Returns the unsubscribe function. */
+    onStopSignal(handler: (signal: StopSignal) => void): () => void;
+    /** Second-signal path only. */
+    exitNow(code: number): never;
+}

package/dist/contracts/IProcessHost.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/IRepositoryLocator.d.ts

@@ -0,0 +1,32 @@
+export interface RepositoryPaths {
+    /** git rev-parse --show-toplevel (D9) */
+    readonly root: string;
+    /** Per worktree; state files live under it. */
+    readonly gitDir: string;
+    /**
+     * The repository's own hooks directory, <git common dir>/hooks, whatever
+     * core.hooksPath says; git runs hooks from it only while core.hooksPath is
+     * unset, which is also the only case the installer writes there (design 14.17).
+     */
+    readonly hooksDir: string;
+    /** <gitDir>/enmetu */
+    readonly stateDir: string;
+}
+export interface GitVersion {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+}
+export type RepositoryLocation = {
+    readonly kind: 'found';
+    readonly paths: RepositoryPaths;
+    readonly version: GitVersion;
+} | {
+    readonly kind: 'not-a-repository';
+} | {
+    readonly kind: 'bare';
+};
+export interface IRepositoryLocator {
+    /** Throws PreflightError PATH_UNSUPPORTED when a repository path contains a newline. */
+    locate(startDir: string): Promise<RepositoryLocation>;
+}

package/dist/contracts/IRepositoryLocator.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/IStateRecorder.d.ts

@@ -0,0 +1,68 @@
+import type { HaltCode } from './IHaltStore.js';
+import type { StateInstance } from './IStateStore.js';
+import type { ConflictKey, CycleOutcome } from './syncTypes.js';
+/** What git says after a cycle about the upstream, read by the recording Decorator. */
+export interface UpstreamFacts {
+    /** The verified ref of the checked-out branch; null when absent, detached or without upstream. */
+    readonly pushed: string | null;
+    /** Ahead count against the tracking ref, else the verified ref; null when neither exists. */
+    readonly unpushed: number | null;
+}
+/** Everything that can change the state record (design 12.1). */
+export type StateEvent = 
+/** The lock is held; nothing else has run. Carries the lock holder's identity. */
+{
+    readonly type: 'started';
+    readonly instance: StateInstance;
+} | {
+    readonly type: 'cycleFinished';
+    readonly cycleId: string;
+    readonly outcome: CycleOutcome;
+    readonly conflict: ConflictKey | null;
+    readonly upstream: UpstreamFacts;
+}
+/** The cycle threw; the state is kept, only the last cycle changes (as in SyncCycleRunner). */
+ | {
+    readonly type: 'cycleFailed';
+    readonly cycleId: string;
+}
+/** Halted outside a cycle: a marker at start, or recovery. */
+ | {
+    readonly type: 'halted';
+    readonly code: HaltCode;
+    readonly message: string;
+}
+/** The run ends without a halt (stopped, or refused by the preflight); written before the lock is released. */
+ | {
+    readonly type: 'stopped';
+    readonly message: string;
+}
+/** enmetu's rebase abort left a person's commit on no branch (design 14.15); the state is unchanged. */
+ | {
+    readonly type: 'commitOrphaned';
+    readonly commit: string;
+    readonly base: string;
+    readonly subject: string;
+};
+/** What the rebase abort knows of a commit it orphaned; the recorder stamps the time. */
+export interface OrphanedCommitFacts {
+    readonly commit: string;
+    readonly base: string;
+    readonly subject: string;
+}
+/**
+ * Observer of enmetu's rebase abort (design 14.15): the one event the abort
+ * reports, so it never sees the lifecycle events of IStateRecorder. Never
+ * throws, like IStateRecorder.
+ */
+export interface IOrphanedCommitRecorder {
+    orphaned(facts: OrphanedCommitFacts): Promise<void>;
+}
+/**
+ * Applies an event to the record and persists it. Never throws: a record that
+ * cannot be written is logged STATE_WRITE_FAILED (once until a write succeeds
+ * again) and syncing goes on.
+ */
+export interface IStateRecorder {
+    record(event: StateEvent): Promise<void>;
+}

package/dist/contracts/IStateRecorder.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/IStateStore.d.ts

@@ -0,0 +1,88 @@
+import type { HaltCode } from './IHaltStore.js';
+import type { ConflictKey, CycleOutcomeKind, PauseReason, WaitReason } from './syncTypes.js';
+/**
+ * What a running enmetu is doing, the machine vocabulary of state.json. A
+ * status indicator maps it to its own words; the status headline is one such
+ * mapping (design 12.2).
+ */
+export type DaemonState = 'starting' | 'synced' | 'waiting' | 'conflict' | 'paused' | 'busy' | 'offline' | 'push-failed' | 'halted' | 'stopped';
+/** Set for paused, waiting and halted; null for every other state. */
+export type StateReason = PauseReason | WaitReason | HaltCode;
+/**
+ * The instance that wrote the record. It is alive when the instance lock's
+ * live holder has the same pid and startedAt (stateLiveness).
+ */
+export interface StateInstance {
+    readonly pid: number;
+    /** Informational, like the lock's. */
+    readonly hostname: string;
+    /** The lock's startedAt, copied when the instance started. */
+    readonly startedAt: string;
+}
+export interface StateTransition {
+    readonly state: DaemonState;
+    readonly reason: StateReason | null;
+    /** ISO-8601 UTC. */
+    readonly at: string;
+}
+export interface LastCycle {
+    readonly cycleId: string;
+    readonly outcome: CycleOutcomeKind;
+    /** ISO-8601 UTC of the cycle's end. */
+    readonly at: string;
+}
+/**
+ * A commit a person made on enmetu's rebase's detached HEAD, left on no branch
+ * when enmetu ended its rebase (COMMIT_ORPHANED, design 14.14, 14.15).
+ */
+export interface OrphanedCommit {
+    /** Full id of HEAD's commit when the rebase ended: the newest orphaned commit. */
+    readonly commit: string;
+    /** Full id of the rebase's own last HEAD; base..commit is what was orphaned. */
+    readonly base: string;
+    /** commit's subject, at most MAX_ORPHAN_SUBJECT_CHARACTERS characters. */
+    readonly subject: string;
+    /** ISO-8601 UTC of when enmetu named it. */
+    readonly at: string;
+}
+/**
+ * <stateDir>/state.json, version 1. Rewritten whole (temp file, then rename)
+ * at every lifecycle event and at the end of every cycle; never appended to.
+ * Fields are written in this order, so the file is byte-stable.
+ */
+export interface StateRecord {
+    readonly version: 1;
+    readonly instance: StateInstance;
+    readonly state: DaemonState;
+    readonly reason: StateReason | null;
+    /** One line for a person, at most MAX_STATE_MESSAGE_CHARACTERS characters. */
+    readonly message: string;
+    /** ISO-8601 UTC of the last change of state or reason. */
+    readonly since: string;
+    /**
+     * The newest commit known to be on the upstream: enmetu's verified ref
+     * (design 1.10), which after enmetu's own push is the commit it pushed.
+     * null before the first verification.
+     */
+    readonly pushed: string | null;
+    /** Local commits not on the last known upstream; null when unknown. */
+    readonly unpushed: number | null;
+    readonly lastCycle: LastCycle | null;
+    /** The held conflict's key while state is 'conflict', else null (design 12.3). */
+    readonly conflict: ConflictKey | null;
+    /** The most recent transitions, oldest first, at most the configured stateHistory. */
+    readonly history: readonly StateTransition[];
+    /**
+     * Orphaned commits enmetu named, oldest first, at most MAX_ORPHANED_COMMITS,
+     * kept across restarts. Whether each is still on no branch is git's to say:
+     * `enmetu status` asks it at every run and shows only those (design 14.15).
+     * A file written before this field existed yields [].
+     */
+    readonly orphaned: readonly OrphanedCommit[];
+}
+export interface IStateStore {
+    /** null when absent, not JSON, of another shape or of another version. */
+    read(): Promise<StateRecord | null>;
+    /** Replaces the whole file atomically (IFileSystem.writeAtomic in the state directory). */
+    write(record: StateRecord): Promise<void>;
+}

package/dist/contracts/IStateStore.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/ISyncCycle.d.ts

@@ -0,0 +1,23 @@
+import type { CommitMemory, ConflictKey, CycleOutcome } from './syncTypes.js';
+/** No trigger: every trigger runs the same chain (Decision 2), so the cycle has no use for it. */
+export interface SyncCycleInput {
+    readonly cycleId: string;
+    readonly knownConflict: ConflictKey | null;
+    /** The previous cycle's commit memory (design 12.7); absent is EMPTY_COMMIT_MEMORY. */
+    readonly commitMemory?: CommitMemory | undefined;
+    /** Consecutive cycles whose rebase git refused to start (Decision 82); absent is 0. */
+    readonly notStartedRebases?: number | undefined;
+}
+export interface SyncCycleResult {
+    readonly outcome: CycleOutcome;
+    /** Set only when a rebase really stopped and its abort was verified. */
+    readonly conflict: ConflictKey | null;
+    /** The commit memory for the next cycle; absent is EMPTY_COMMIT_MEMORY. */
+    readonly commitMemory?: CommitMemory | undefined;
+    /** The count for the next cycle (Decision 82); absent is 0. */
+    readonly notStartedRebases?: number | undefined;
+}
+/** One cycle with its deps bound: a closure over syncCycleController, built by the composition root. */
+export interface ISyncCycle {
+    run(input: SyncCycleInput): Promise<SyncCycleResult>;
+}

package/dist/contracts/ISyncCycle.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/ISyncCycleRunner.d.ts

@@ -0,0 +1,4 @@
+import type { CycleOutcomeKind } from './syncTypes.js';
+export interface ISyncCycleRunner {
+    run(): Promise<CycleOutcomeKind>;
+}

package/dist/contracts/ISyncCycleRunner.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/ISyncScheduler.d.ts

@@ -0,0 +1,6 @@
+export interface ISyncScheduler {
+    /** Dispatches 'started'; resolves when the scheduler ends. */
+    run(): Promise<'stopped' | 'halted'>;
+    notifyChange(): void;
+    stop(): void;
+}

package/dist/contracts/ISyncScheduler.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/ITextSink.d.ts

@@ -0,0 +1,3 @@
+export interface ITextSink {
+    write(text: string): unknown;
+}

package/dist/contracts/ITextSink.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/IWatcher.d.ts

@@ -0,0 +1,9 @@
+export interface WatchListener {
+    onChange(): void;
+    onFailure(detail: string): void;
+}
+export interface IWatcher {
+    /** Recursive watch of the repository root; noise is filtered inside; no path is passed on. */
+    start(listener: WatchListener): void;
+    close(): void;
+}

package/dist/contracts/IWatcher.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/config.d.ts

@@ -0,0 +1,26 @@
+export interface EnmetuConfig {
+    readonly quietMs: number;
+    readonly maxDelayMs: number;
+    readonly pollMs: number;
+    readonly commitSubject: string;
+    readonly installHook: boolean;
+    readonly skipJsonCheck: readonly string[];
+    readonly gitTimeoutMs: number;
+    /** Transitions kept in state.json; 0 keeps none (design 12.1). */
+    readonly stateHistory: number;
+    /**
+     * While a person has a partial staging, how long enmetu waits before it
+     * commits everything, the staging included; 0 commits at once (design 14.17).
+     */
+    readonly partialStagingWaitMs: number;
+    /** Run the repository's commit hooks for enmetu's commits (design 12.7). */
+    readonly commitHooks: boolean;
+    /** How long one repository hook may run before it is a rejection (design 12.7, Decision 83). */
+    readonly hookTimeoutMs: number;
+}
+/** What parseConfig read: the config, and the keys it does not know, in file order (design 14.17). */
+export interface ParsedConfig {
+    readonly config: EnmetuConfig;
+    /** Ignored; the run command names each once at start. */
+    readonly unknownKeys: readonly string[];
+}

package/dist/contracts/config.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/errors.d.ts

@@ -0,0 +1,39 @@
+import type { HaltCode } from './IHaltStore.js';
+export type EnmetuErrorCode = 'GIT_NOT_FOUND' | 'GIT_TIMEOUT' | 'GIT_ABORTED' | 'GIT_FAILED' | 'GIT_INDEX_LOCKED' | 'GIT_OUTPUT_UNPARSEABLE' | 'CONFIG_INVALID_JSON' | 'CONFIG_INVALID_VALUE' | 'NOT_A_REPOSITORY' | 'BARE_REPOSITORY' | 'GIT_TOO_OLD' | 'PATH_UNSUPPORTED' | 'OPERATION_IN_PROGRESS' | 'DETACHED_HEAD' | 'HEAD_UNBORN' | 'NO_UPSTREAM' | 'UPSTREAM_NOT_REMOTE' | 'IDENTITY_MISSING' | 'LOCK_HELD' | 'LOCK_UNREADABLE' | 'HALTED' | 'USAGE';
+export type GitCommandErrorCode = 'GIT_NOT_FOUND' | 'GIT_TIMEOUT' | 'GIT_ABORTED' | 'GIT_FAILED' | 'GIT_INDEX_LOCKED';
+export type ConfigErrorCode = 'CONFIG_INVALID_JSON' | 'CONFIG_INVALID_VALUE';
+export type PreflightErrorCode = 'NOT_A_REPOSITORY' | 'BARE_REPOSITORY' | 'GIT_TOO_OLD' | 'PATH_UNSUPPORTED' | 'OPERATION_IN_PROGRESS' | 'DETACHED_HEAD' | 'HEAD_UNBORN' | 'NO_UPSTREAM' | 'UPSTREAM_NOT_REMOTE' | 'IDENTITY_MISSING';
+export type LockErrorCode = 'LOCK_HELD' | 'LOCK_UNREADABLE';
+export declare class EnmetuError extends Error {
+    readonly code: EnmetuErrorCode;
+    readonly cycleId?: string | undefined;
+    constructor(message: string, code: EnmetuErrorCode, cycleId?: string | undefined);
+}
+export declare class GitCommandError extends EnmetuError {
+    readonly args: readonly string[];
+    readonly exitCode: number | null;
+    readonly stderr: string;
+    constructor(message: string, code: GitCommandErrorCode, args: readonly string[], exitCode: number | null, stderr: string, cycleId?: string | undefined);
+}
+/** GIT_OUTPUT_UNPARSEABLE, raised by the porcelain parsers. */
+export declare class GitOutputError extends EnmetuError {
+    constructor(message: string, cycleId?: string | undefined);
+}
+export declare class ConfigError extends EnmetuError {
+    readonly key: string | null;
+    constructor(message: string, code: ConfigErrorCode, key: string | null);
+}
+export declare class PreflightError extends EnmetuError {
+    constructor(message: string, code: PreflightErrorCode, cycleId?: string | undefined);
+}
+export declare class LockError extends EnmetuError {
+    constructor(message: string, code: LockErrorCode);
+}
+/** Thrown by HaltGuardGitWriter for every write while halt.json exists. */
+export declare class HaltedError extends EnmetuError {
+    readonly haltCode: HaltCode;
+    constructor(message: string, haltCode: HaltCode, cycleId?: string | undefined);
+}
+export declare class UsageError extends EnmetuError {
+    constructor(message: string);
+}

package/dist/contracts/errors.js

@@ -0,0 +1,64 @@
+export class EnmetuError extends Error {
+    code;
+    cycleId;
+    constructor(message, code, cycleId) {
+        super(message);
+        this.code = code;
+        this.cycleId = cycleId;
+        this.name = 'EnmetuError';
+    }
+}
+export class GitCommandError extends EnmetuError {
+    args;
+    exitCode;
+    stderr;
+    constructor(message, code, args, exitCode, stderr, cycleId) {
+        super(message, code, cycleId);
+        this.args = args;
+        this.exitCode = exitCode;
+        this.stderr = stderr;
+        this.name = 'GitCommandError';
+    }
+}
+/** GIT_OUTPUT_UNPARSEABLE, raised by the porcelain parsers. */
+export class GitOutputError extends EnmetuError {
+    constructor(message, cycleId) {
+        super(message, 'GIT_OUTPUT_UNPARSEABLE', cycleId);
+        this.name = 'GitOutputError';
+    }
+}
+export class ConfigError extends EnmetuError {
+    key;
+    constructor(message, code, key) {
+        super(message, code);
+        this.key = key;
+        this.name = 'ConfigError';
+    }
+}
+export class PreflightError extends EnmetuError {
+    constructor(message, code, cycleId) {
+        super(message, code, cycleId);
+        this.name = 'PreflightError';
+    }
+}
+export class LockError extends EnmetuError {
+    constructor(message, code) {
+        super(message, code);
+        this.name = 'LockError';
+    }
+}
+/** Thrown by HaltGuardGitWriter for every write while halt.json exists. */
+export class HaltedError extends EnmetuError {
+    haltCode;
+    constructor(message, haltCode, cycleId) {
+        super(message, 'HALTED', cycleId);
+        this.haltCode = haltCode;
+        this.name = 'HaltedError';
+    }
+}
+export class UsageError extends EnmetuError {
+    constructor(message) {
+        super(message, 'USAGE');
+        this.name = 'UsageError';
+    }
+}

package/dist/contracts/exitCode.d.ts

@@ -0,0 +1,10 @@
+export type ExitCode = 0 | 1 | 2 | 3 | 4 | 5 | 130;
+export declare const EXIT: {
+    readonly OK: 0;
+    readonly FAILURE: 1;
+    readonly USAGE: 2;
+    readonly HALTED: 3;
+    readonly LOCKED: 4;
+    readonly NOT_ELIGIBLE: 5;
+    readonly SECOND_SIGNAL: 130;
+};

package/dist/contracts/exitCode.js

@@ -0,0 +1,17 @@
+// Annotated instead of a const assertion: the house rules allow no type assertion.
+export const EXIT = {
+    // stopped by a signal, status printed, halt cleared, hook passed
+    OK: 0,
+    // unexpected error; also the hook's "commit refused"
+    FAILURE: 1,
+    // bad arguments or invalid enmetu.config.json
+    USAGE: 2,
+    // halt marker present (run, status), resume refused, or halted while running
+    HALTED: 3,
+    // another live instance holds the lock (run, resume)
+    LOCKED: 4,
+    // not a repository, bare, git missing or too old, detached, unborn, no upstream, operation in progress, no identity
+    NOT_ELIGIBLE: 5,
+    // second stop signal; exits at once
+    SECOND_SIGNAL: 130,
+};