@fluado/enmetu 0.0.0-stage → 0.1.0

package/dist/core/git/enmetuRefs.js

@@ -0,0 +1,22 @@
+/**
+ * enmetu's own refs. They live outside refs/heads, refs/remotes and refs/tags,
+ * so no fetch refspec, push or person's command moves them, and a push that
+ * names branchRef never sends them.
+ */
+const BRANCH_PREFIX = 'refs/heads/';
+/** The last upstream sha enmetu verified to be a fast-forward or pushed itself: refs/enmetu/verified/<branch>. */
+export function verifiedRefFor(branchRef) {
+    return `refs/enmetu/verified/${branchName(branchRef)}`;
+}
+/** Where enmetu fetches before verifying: refs/enmetu/incoming/<branch>. */
+export function incomingRefFor(branchRef) {
+    return `refs/enmetu/incoming/${branchName(branchRef)}`;
+}
+// Callers pass the branchRef of `git symbolic-ref HEAD`, always under
+// refs/heads/. Anything else keeps its full name, so two inputs never map
+// to the same enmetu ref.
+function branchName(branchRef) {
+    return branchRef.startsWith(BRANCH_PREFIX)
+        ? branchRef.slice(BRANCH_PREFIX.length)
+        : branchRef;
+}

package/dist/core/git/porcelain.d.ts

@@ -0,0 +1,51 @@
+import type { Divergence, StatusEntry, Upstream } from '../../contracts/gitTypes.js';
+import type { GitVersion } from '../../contracts/IRepositoryLocator.js';
+/**
+ * Parsers and guards for every git output enmetu reads. Malformed output
+ * throws GitOutputError GIT_OUTPUT_UNPARSEABLE; an answer meaning "absent"
+ * (no upstream, ref not listed, unknown version) returns null.
+ */
+export interface RawDiffEntry {
+    /** New mode, e.g. 100644, 100755, 120000, 160000. */
+    readonly mode: string;
+    /** New blob id. */
+    readonly blobId: string;
+    readonly path: string;
+}
+export type BatchCheckEntry = {
+    readonly kind: 'found';
+    readonly id: string;
+    readonly size: number;
+} | {
+    readonly kind: 'missing';
+    readonly id: string;
+};
+export interface BatchBlob {
+    readonly id: string;
+    readonly content: Buffer;
+}
+export interface RevParsePaths {
+    readonly root: string;
+    readonly gitDir: string;
+    readonly hooksDir: string;
+}
+/** `git status --porcelain=v1 -z` records; a rename or copy record consumes its source path field. */
+export declare function parseStatus(stdout: Buffer): readonly StatusEntry[];
+/** `git diff --cached --raw -z --no-abbrev` records. */
+export declare function parseRawDiff(stdout: Buffer): readonly RawDiffEntry[];
+/** The sha of exactly `ref` in `git ls-remote` output, null when the ref is not listed. */
+export declare function parseLsRemote(stdout: string, ref: string): string | null;
+/** `git rev-list --left-right --count HEAD...<sha>` output. */
+export declare function parseDivergence(stdout: string): Divergence;
+/** `git version` output, null when the format is unknown. */
+export declare function parseGitVersion(stdout: string): GitVersion | null;
+/** `git cat-file --batch-check` output, one entry per requested id. */
+export declare function parseBatchCheck(stdout: string): readonly BatchCheckEntry[];
+/** `git cat-file --batch` output split by each header's declared size. */
+export declare function parseBatch(stdout: Buffer): readonly BatchBlob[];
+/** for-each-ref `%(upstream:remotename)%00%(upstream:remoteref)%00%(upstream)` output; null without an upstream. */
+export declare function parseUpstream(stdout: string, branchRef: string): Upstream | null;
+/** The three absolute paths of rev-parse; null unless exactly three absolute lines (a path with a newline). */
+export declare function parseRevParsePaths(stdout: string): RevParsePaths | null;
+/** true when `git push --porcelain` output carries a ref line starting with `!`. */
+export declare function hasRejectedRef(stdout: string): boolean;

package/dist/core/git/porcelain.js

@@ -0,0 +1,219 @@
+import { GitOutputError } from '../../contracts/errors.js';
+const STATUS_CODES = [
+    ' ',
+    'M',
+    'T',
+    'A',
+    'D',
+    'R',
+    'C',
+    'U',
+    '?',
+    '!',
+];
+// SHA-1 ids are 40 hex digits, SHA-256 ids 64.
+const OBJECT_ID = '[0-9a-f]{40}(?:[0-9a-f]{24})?';
+const RAW_DIFF_HEADER = new RegExp(`^:[0-7]{6} ([0-7]{6}) ${OBJECT_ID} (${OBJECT_ID}) ([A-Z])[0-9]*$`);
+const LS_REMOTE_LINE = new RegExp(`^(${OBJECT_ID})\t(.+)$`);
+const BATCH_CHECK_FOUND = new RegExp(`^(${OBJECT_ID}) blob ([0-9]+)$`);
+const BATCH_CHECK_MISSING = new RegExp(`^(${OBJECT_ID}) missing$`);
+const BATCH_HEADER = BATCH_CHECK_FOUND;
+const DIVERGENCE_LINE = /^([0-9]+)\t([0-9]+)$/;
+const GIT_VERSION = /^git version ([0-9]+)\.([0-9]+)\.([0-9]+)/;
+const NEWLINE = 0x0a;
+/** `git status --porcelain=v1 -z` records; a rename or copy record consumes its source path field. */
+export function parseStatus(stdout) {
+    const records = nulTerminatedFields(stdout, 'git status');
+    const entries = [];
+    for (let i = 0; i < records.length; i += 1) {
+        const record = records[i] ?? '';
+        if (record.length < 4 || record[2] !== ' ') {
+            throw unparseable('git status', record);
+        }
+        const index = statusCode(record[0], record);
+        const worktree = statusCode(record[1], record);
+        entries.push({ index, worktree, path: record.slice(3) });
+        if (isRenameOrCopy(index) || isRenameOrCopy(worktree)) {
+            const source = records[i + 1];
+            if (source === undefined || source === '') {
+                throw unparseable('git status', record);
+            }
+            i += 1;
+        }
+    }
+    return entries;
+}
+/** `git diff --cached --raw -z --no-abbrev` records. */
+export function parseRawDiff(stdout) {
+    const fields = nulTerminatedFields(stdout, 'git diff --raw');
+    const entries = [];
+    let i = 0;
+    while (i < fields.length) {
+        const header = fields[i] ?? '';
+        const match = RAW_DIFF_HEADER.exec(header);
+        const mode = match?.[1];
+        const blobId = match?.[2];
+        const status = match?.[3];
+        if (mode === undefined || blobId === undefined || status === undefined) {
+            throw unparseable('git diff --raw', header);
+        }
+        // A rename or copy carries its source path before the destination.
+        const pathCount = isRenameOrCopy(status) ? 2 : 1;
+        const path = fields[i + pathCount];
+        if (path === undefined || path === '') {
+            throw unparseable('git diff --raw', header);
+        }
+        entries.push({ mode, blobId, path });
+        i += 1 + pathCount;
+    }
+    return entries;
+}
+/** The sha of exactly `ref` in `git ls-remote` output, null when the ref is not listed. */
+export function parseLsRemote(stdout, ref) {
+    for (const line of nonEmptyLines(stdout)) {
+        const match = LS_REMOTE_LINE.exec(line);
+        const sha = match?.[1];
+        const listedRef = match?.[2];
+        if (sha === undefined || listedRef === undefined) {
+            throw unparseable('git ls-remote', line);
+        }
+        if (listedRef === ref) {
+            return sha;
+        }
+    }
+    return null;
+}
+/** `git rev-list --left-right --count HEAD...<sha>` output. */
+export function parseDivergence(stdout) {
+    const line = stdout.trimEnd();
+    const match = DIVERGENCE_LINE.exec(line);
+    const ahead = match?.[1];
+    const behind = match?.[2];
+    if (ahead === undefined || behind === undefined) {
+        throw unparseable('git rev-list --count', line);
+    }
+    return { ahead: Number(ahead), behind: Number(behind) };
+}
+/** `git version` output, null when the format is unknown. */
+export function parseGitVersion(stdout) {
+    const match = GIT_VERSION.exec(stdout);
+    const major = match?.[1];
+    const minor = match?.[2];
+    const patch = match?.[3];
+    if (major === undefined || minor === undefined || patch === undefined) {
+        return null;
+    }
+    return { major: Number(major), minor: Number(minor), patch: Number(patch) };
+}
+/** `git cat-file --batch-check` output, one entry per requested id. */
+export function parseBatchCheck(stdout) {
+    return nonEmptyLines(stdout).map((line) => {
+        const found = BATCH_CHECK_FOUND.exec(line);
+        const foundId = found?.[1];
+        const size = found?.[2];
+        if (foundId !== undefined && size !== undefined) {
+            return { kind: 'found', id: foundId, size: Number(size) };
+        }
+        const missingId = BATCH_CHECK_MISSING.exec(line)?.[1];
+        if (missingId !== undefined) {
+            return { kind: 'missing', id: missingId };
+        }
+        throw unparseable('git cat-file --batch-check', line);
+    });
+}
+/** `git cat-file --batch` output split by each header's declared size. */
+export function parseBatch(stdout) {
+    const blobs = [];
+    let offset = 0;
+    while (offset < stdout.length) {
+        const headerEnd = stdout.indexOf(NEWLINE, offset);
+        if (headerEnd === -1) {
+            throw unparseable('git cat-file --batch', stdout.toString('utf8', offset));
+        }
+        const header = stdout.toString('utf8', offset, headerEnd);
+        const match = BATCH_HEADER.exec(header);
+        const id = match?.[1];
+        const size = match?.[2];
+        if (id === undefined || size === undefined) {
+            throw unparseable('git cat-file --batch', header);
+        }
+        const contentStart = headerEnd + 1;
+        const contentEnd = contentStart + Number(size);
+        if (contentEnd >= stdout.length || stdout[contentEnd] !== NEWLINE) {
+            throw unparseable('git cat-file --batch', header);
+        }
+        // A view, not a copy: the chunk is alive while its files are consumed anyway.
+        blobs.push({ id, content: stdout.subarray(contentStart, contentEnd) });
+        offset = contentEnd + 1;
+    }
+    return blobs;
+}
+/** for-each-ref `%(upstream:remotename)%00%(upstream:remoteref)%00%(upstream)` output; null without an upstream. */
+export function parseUpstream(stdout, branchRef) {
+    const line = stripOneTrailingNewline(stdout);
+    // No output: the branch ref does not exist (an unborn HEAD).
+    if (line === '') {
+        return null;
+    }
+    const fields = line.split('\0');
+    if (fields.length !== 3) {
+        throw unparseable('git for-each-ref', line);
+    }
+    const [remote, remoteRef, trackingRef] = fields;
+    // An empty field is an upstream git cannot resolve to a remote-tracking
+    // ref; the cycle treats it like no upstream at all.
+    if (!remote || !remoteRef || !trackingRef) {
+        return null;
+    }
+    return { branchRef, remote, remoteRef, trackingRef };
+}
+/** The three absolute paths of rev-parse; null unless exactly three absolute lines (a path with a newline). */
+export function parseRevParsePaths(stdout) {
+    const lines = stripOneTrailingNewline(stdout).split('\n');
+    if (lines.length !== 3 || !lines.every((line) => line.startsWith('/'))) {
+        return null;
+    }
+    const [root, gitDir, hooksDir] = lines;
+    if (root === undefined || gitDir === undefined || hooksDir === undefined) {
+        return null;
+    }
+    return { root, gitDir, hooksDir };
+}
+/** true when `git push --porcelain` output carries a ref line starting with `!`. */
+export function hasRejectedRef(stdout) {
+    return stdout.split('\n').some((line) => line.startsWith('!'));
+}
+/**
+ * Splits `-z` output into its fields. Every field is NUL-terminated, so
+ * output that does not end in NUL was cut off.
+ */
+function nulTerminatedFields(stdout, command) {
+    const text = stdout.toString('utf8');
+    if (text === '') {
+        return [];
+    }
+    if (!text.endsWith('\0')) {
+        throw unparseable(command, text);
+    }
+    return text.slice(0, -1).split('\0');
+}
+function nonEmptyLines(stdout) {
+    return stdout.split('\n').filter((line) => line !== '');
+}
+function stripOneTrailingNewline(stdout) {
+    return stdout.endsWith('\n') ? stdout.slice(0, -1) : stdout;
+}
+function statusCode(char, record) {
+    const code = STATUS_CODES.find((candidate) => candidate === char);
+    if (code === undefined) {
+        throw unparseable('git status', record);
+    }
+    return code;
+}
+function isRenameOrCopy(code) {
+    return code === 'R' || code === 'C';
+}
+const EXCERPT_LENGTH = 120;
+function unparseable(command, excerpt) {
+    return new GitOutputError(`unexpected ${command} output: ${JSON.stringify(excerpt.slice(0, EXCERPT_LENGTH))}`);
+}

package/dist/core/git/rebaseOwnership.d.ts

@@ -0,0 +1,28 @@
+import type { RebaseStart } from '../../contracts/gitTypes.js';
+import type { RebaseJournal } from '../../contracts/IOperationJournal.js';
+/**
+ * Who started the rebase in progress (design 13.2, Decision 104):
+ * - enmetu: HEAD's newest start entry carries this attempt's token;
+ * - other: every other start entry (a person's command, an earlier attempt of
+ *   enmetu's) or none at all while HEAD has a reflog;
+ * - unknown: HEAD has no reflog, so only orig-head and onto can decide.
+ */
+export type RebaseOwner = 'enmetu' | 'other' | 'unknown';
+/**
+ * The attempt's token, GIT_REFLOG_ACTION for its `git rebase`. Built from the
+ * journal entry begun for the attempt, so startup recovery rebuilds the same
+ * token from the journal it reads. Cycle ids restart with every process; the
+ * entry's time keeps two processes' tokens apart (one instance per repository
+ * at a time, and a restart takes longer than a millisecond).
+ */
+export declare function rebaseReflogAction(journal: Pick<RebaseJournal, 'cycleId' | 'at'>): string;
+/**
+ * enmetu only when the newest start entry's action equals
+ * rebaseReflogAction(journal); git writes that entry when the rebase checks
+ * out onto, before any pick can stop it, so a stopped rebase of this attempt
+ * always has it (probe W of design 13.10). Positive on purpose: a person's
+ * rebase held between creating its directory and its checkout has not
+ * written its entry yet, so "the newest entry is someone else's" would miss
+ * it, while "the newest entry is not this attempt's" does not.
+ */
+export declare function rebaseOwner(start: RebaseStart, journal: RebaseJournal): RebaseOwner;

package/dist/core/git/rebaseOwnership.js

@@ -0,0 +1,29 @@
+/**
+ * The attempt's token, GIT_REFLOG_ACTION for its `git rebase`. Built from the
+ * journal entry begun for the attempt, so startup recovery rebuilds the same
+ * token from the journal it reads. Cycle ids restart with every process; the
+ * entry's time keeps two processes' tokens apart (one instance per repository
+ * at a time, and a restart takes longer than a millisecond).
+ */
+export function rebaseReflogAction(journal) {
+    return `enmetu ${journal.cycleId} ${journal.at}`;
+}
+/**
+ * enmetu only when the newest start entry's action equals
+ * rebaseReflogAction(journal); git writes that entry when the rebase checks
+ * out onto, before any pick can stop it, so a stopped rebase of this attempt
+ * always has it (probe W of design 13.10). Positive on purpose: a person's
+ * rebase held between creating its directory and its checkout has not
+ * written its entry yet, so "the newest entry is someone else's" would miss
+ * it, while "the newest entry is not this attempt's" does not.
+ */
+export function rebaseOwner(start, journal) {
+    switch (start.kind) {
+        case 'unlogged':
+            return 'unknown';
+        case 'none':
+            return 'other';
+        case 'entry':
+            return start.action === rebaseReflogAction(journal) ? 'enmetu' : 'other';
+    }
+}

package/dist/core/git/stoppedRebaseWrites.d.ts

@@ -0,0 +1,10 @@
+import type { StatusEntry } from '../../contracts/gitTypes.js';
+/**
+ * Paths written while a rebase was stopped, which `git rebase --abort` would
+ * reset to orig-head (Decision 45): a worktree modification, deletion or type
+ * change on an entry that is not unmerged. Paths the rebase itself staged show
+ * a clean worktree column. Unmerged entries (either column U, or AA and DD)
+ * carry git's conflict content, which the abort is meant to discard; a write
+ * into one cannot be told apart from it, the named residual.
+ */
+export declare function writesDuringStoppedRebase(entries: readonly StatusEntry[]): readonly string[];

package/dist/core/git/stoppedRebaseWrites.js

@@ -0,0 +1,22 @@
+/**
+ * Paths written while a rebase was stopped, which `git rebase --abort` would
+ * reset to orig-head (Decision 45): a worktree modification, deletion or type
+ * change on an entry that is not unmerged. Paths the rebase itself staged show
+ * a clean worktree column. Unmerged entries (either column U, or AA and DD)
+ * carry git's conflict content, which the abort is meant to discard; a write
+ * into one cannot be told apart from it, the named residual.
+ */
+export function writesDuringStoppedRebase(entries) {
+    return entries
+        .filter((entry) => isWorktreeWrite(entry) && !isUnmerged(entry))
+        .map((entry) => entry.path);
+}
+function isWorktreeWrite(entry) {
+    return (entry.worktree === 'M' || entry.worktree === 'D' || entry.worktree === 'T');
+}
+function isUnmerged(entry) {
+    return (entry.index === 'U' ||
+        entry.worktree === 'U' ||
+        (entry.index === 'A' && entry.worktree === 'A') ||
+        (entry.index === 'D' && entry.worktree === 'D'));
+}

package/dist/core/halt/resumeHint.d.ts

@@ -0,0 +1,6 @@
+import type { HaltCode } from '../../contracts/IHaltStore.js';
+/**
+ * What a person does to clear a halt; the daemon's HALTED lines and status print
+ * it. Null: the code is not known (the marker was cleared before it was read).
+ */
+export declare function resumeHint(code: HaltCode | null): string;

package/dist/core/halt/resumeHint.js

@@ -0,0 +1,9 @@
+/**
+ * What a person does to clear a halt; the daemon's HALTED lines and status print
+ * it. Null: the code is not known (the marker was cleared before it was read).
+ */
+export function resumeHint(code) {
+    return code === 'UPSTREAM_REWRITTEN'
+        ? 'Reconcile the branch with the rewritten upstream, then run: enmetu resume --accept-upstream'
+        : 'Reconcile the branch, then run: enmetu resume';
+}

package/dist/core/log/formatLogLine.d.ts

@@ -0,0 +1,3 @@
+import type { LogEntry } from '../../contracts/ILogger.js';
+/** `<ISO-8601 UTC with ms> <LEVEL padded to 5> <cycleId or -> <CODE> <message>`, newlines in the message replaced by ` | `. */
+export declare function formatLogLine(entry: LogEntry, epochMs: number): string;

package/dist/core/log/formatLogLine.js

@@ -0,0 +1,11 @@
+/** `<ISO-8601 UTC with ms> <LEVEL padded to 5> <cycleId or -> <CODE> <message>`, newlines in the message replaced by ` | `. */
+export function formatLogLine(entry, epochMs) {
+    const timestamp = new Date(epochMs).toISOString();
+    const level = entry.level.padEnd(5);
+    const cycleId = (entry.cycleId ?? '-').padEnd(3);
+    // git stderr ends in a newline and spans several lines; a log entry is one line.
+    const message = entry.message
+        .replace(/(?:\r?\n)+$/, '')
+        .replace(/\r?\n/g, ' | ');
+    return `${timestamp} ${level} ${cycleId} ${entry.code} ${message}`;
+}

package/dist/core/quarantine/keptBlobMessage.d.ts

@@ -0,0 +1,5 @@
+import type { KeptBlob } from '../../contracts/IPathQuarantine.js';
+/** The QUARANTINE_KEPT message, the same wherever a restore keeps a blob (1.13). */
+export declare function keptBlobMessage(kept: KeptBlob): string;
+/** The QUARANTINE_KEPT message for a write the restore replaced after its last check (Decision 117). */
+export declare function overwrittenBlobMessage(kept: KeptBlob): string;

package/dist/core/quarantine/keptBlobMessage.js

@@ -0,0 +1,8 @@
+/** The QUARANTINE_KEPT message, the same wherever a restore keeps a blob (1.13). */
+export function keptBlobMessage(kept) {
+    return `${kept.path} changed while it was held; the held version is blob ${kept.blobId} (git cat-file -p ${kept.blobId}), kept until git gc prunes it`;
+}
+/** The QUARANTINE_KEPT message for a write the restore replaced after its last check (Decision 117). */
+export function overwrittenBlobMessage(kept) {
+    return `${kept.path} was written while enmetu put its held version back, after enmetu's last check of the file; that write is blob ${kept.blobId} (git cat-file -p ${kept.blobId}), kept until git gc prunes it, and the file holds the held version`;
+}

package/dist/core/quarantine/restoreWarnings.d.ts

@@ -0,0 +1,16 @@
+import type { ILogger } from '../../contracts/ILogger.js';
+import type { KeptBlob } from '../../contracts/IPathQuarantine.js';
+/** What a restore reports that a person should see; the fields of RestoreResult's restored. */
+export interface RestoreWarnings {
+    readonly kept: readonly KeptBlob[];
+    readonly changedUnderHold: readonly string[];
+    readonly overwritten: readonly KeptBlob[];
+}
+/** The QUARANTINE_UPSTREAM_CHANGED message (Decision 99). */
+export declare function changedUnderHoldMessage(path: string): string;
+/**
+ * One WARN per kept blob and per path restored over a change, the same at
+ * every restore: recovery, a pending memento, and integrate (written three
+ * times before it was extracted).
+ */
+export declare function logRestoreWarnings(warnings: RestoreWarnings, cycleId: string, logger: ILogger): void;

package/dist/core/quarantine/restoreWarnings.js

@@ -0,0 +1,36 @@
+import { keptBlobMessage, overwrittenBlobMessage } from './keptBlobMessage.js';
+/** The QUARANTINE_UPSTREAM_CHANGED message (Decision 99). */
+export function changedUnderHoldMessage(path) {
+    return `${path} changed in HEAD while it was held (a pulled change) and the held edits do not merge cleanly onto it; the held version is back in the working tree, so committing it undoes that change (compare with git diff HEAD -- ${path})`;
+}
+/**
+ * One WARN per kept blob and per path restored over a change, the same at
+ * every restore: recovery, a pending memento, and integrate (written three
+ * times before it was extracted).
+ */
+export function logRestoreWarnings(warnings, cycleId, logger) {
+    for (const kept of warnings.kept) {
+        logger.log({
+            level: 'WARN',
+            code: 'QUARANTINE_KEPT',
+            message: keptBlobMessage(kept),
+            cycleId,
+        });
+    }
+    for (const overwritten of warnings.overwritten) {
+        logger.log({
+            level: 'WARN',
+            code: 'QUARANTINE_KEPT',
+            message: overwrittenBlobMessage(overwritten),
+            cycleId,
+        });
+    }
+    for (const path of warnings.changedUnderHold) {
+        logger.log({
+            level: 'WARN',
+            code: 'QUARANTINE_UPSTREAM_CHANGED',
+            message: changedUnderHoldMessage(path),
+            cycleId,
+        });
+    }
+}

package/dist/core/schedule/schedulerStep.d.ts

@@ -0,0 +1,63 @@
+import type { CycleOutcomeKind } from '../../contracts/syncTypes.js';
+export type SchedulerState = {
+    readonly kind: 'idle';
+} | {
+    readonly kind: 'waiting';
+    readonly firstChangeAt: number;
+    readonly lastChangeAt: number;
+} | {
+    readonly kind: 'syncing';
+    readonly changedDuringSync: boolean;
+} | {
+    readonly kind: 'stopping';
+} | {
+    readonly kind: 'stopped';
+} | {
+    readonly kind: 'halted';
+};
+export type SchedulerEvent = {
+    readonly type: 'started';
+} | {
+    readonly type: 'changed';
+    readonly at: number;
+} | {
+    readonly type: 'quietElapsed';
+} | {
+    readonly type: 'pollDue';
+    readonly at: number;
+} | {
+    readonly type: 'cycleFinished';
+    readonly at: number;
+    readonly outcome: CycleOutcomeKind;
+} | {
+    readonly type: 'stopRequested';
+};
+export type SchedulerEffect = {
+    readonly type: 'runCycle';
+} | {
+    readonly type: 'armQuietTimer';
+    readonly fireAt: number;
+} | {
+    readonly type: 'armPollTimer';
+    readonly fireAt: number;
+} | {
+    readonly type: 'cancelTimers';
+} | {
+    readonly type: 'end';
+    readonly reason: 'stopped' | 'halted';
+};
+export interface SchedulerTiming {
+    readonly quietMs: number;
+    readonly maxDelayMs: number;
+    readonly pollMs: number;
+}
+export interface SchedulerStepResult {
+    readonly state: SchedulerState;
+    readonly effects: readonly SchedulerEffect[];
+}
+export declare const INITIAL_SCHEDULER_STATE: SchedulerState;
+/**
+ * The transitions of design 1.15, one function per state. Every event a
+ * state does not draw returns that state unchanged with no effects.
+ */
+export declare function schedulerStep(state: SchedulerState, event: SchedulerEvent, timing: SchedulerTiming): SchedulerStepResult;