sidediff 0.2.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Shane Keulen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# sidediff
+
+GitHub-style diff review in the browser, with a live notes column. Built on [`@pierre/diffs`](https://diffs.com).
+
+- GitHub-style review: a collapsible file tree, split or unified diffs, per-file Viewed checkboxes with a progress bar, and a third column of notes aligned to the lines they describe.
+- Base16 Tomorrow Night and Tomorrow Night Eighties themes with muted change highlighting and a near-black code background.
+- Expand unmodified lines between hunks, like GitHub; the server serves both sides of the range.
+- Viewed marks are stored per repository in the browser and clear themselves when a file changes again, like GitHub.
+- Watch mode by default: edits, commits and checkouts re-render the page without a refresh.
+- Notes are plain files that any tool or agent can write while you read; they appear immediately.
+
+## Install
+
+Not published to npm. Install from source:
+
+```sh
+git clone https://github.com/SeeThruHead/sidediff.git
+cd sidediff
+pnpm install
+pnpm run build
+npm link
+```
+
+## Use
+
+```sh
+sidediff                      # working tree against HEAD
+sidediff origin/main...HEAD   # a branch against its base
+sidediff HEAD~1 --no-watch    # a fixed range, no watching
+```
+
+Options: `--port` (default 4977, falls back to the next free port), `--host` (default 127.0.0.1), `--no-open`, `--no-watch`. Any other arguments are passed to `git diff`.
+
+Keys: `s` split or unified, `a` show or hide notes, `n` / `p` next or previous note.
+
+## Notes
+
+```sh
+sidediff note add --file src/app.ts --new-line 42 --summary "Why this changed" --rationale "Longer explanation"
+echo '{"comments":[{"filePath":"src/app.ts","newLine":42,"summary":"Why"}]}' | sidediff note apply
+sidediff note list [--json] [--file src/app.ts]
+sidediff note rm <id>
+sidediff note clear [--file src/app.ts]
+```
+
+`--new-line` targets the new side of the diff, `--old-line` the old side. The batch format matches Hunk's `session comment apply`, so existing agent tooling can target either.
+
+Notes are stored one file per note under `<git dir>/sidediff/notes`, so concurrent writers never collide and nothing is committed to the repository.
+
+## Guided tours and conversation
+
+A running server accepts commands that drive the open page, so a person or an agent can walk someone through a change:
+
+```sh
+sidediff show src/app.ts:40                     # scroll there
+sidediff highlight src/app.ts:40-48 --text userId   # select lines and mark text
+sidediff explain src/app.ts:40-48 --title "Why" --body "..." [--speak]   # zoomed popover over the diff
+sidediff say "Next, the worker"                 # spoken through the browser, with a caption
+sidediff clear
+sidediff tour tour.json                         # steps array of the commands above; Next/Back in the page, or ] and [
+sidediff where                                  # which file the reader is on
+sidediff listen [--after <id>] [--wait 600]     # blocks until the reader says something
+```
+
+Press Talk (or `m`) in the page to speak. Recognition uses the browser's built-in speech service (Chrome sends audio to Google; Safari uses Apple's), each finished sentence is posted to the server, and `sidediff listen` returns it. Replies are read aloud with the browser's speech synthesis.
+
+## Develop
+
+```sh
+pnpm install
+pnpm run build      # client and CLI
+pnpm run dev        # rebuild the client on change
+pnpm run typecheck
+```
+
+MIT licensed.

package/dist/cli.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { NodeRuntime, NodeServices, NodeSocket } from '@effect/platform-node';
+import { Console, Context, Duration, Effect, FileSystem, Layer, Option, Schema, Stdio, Stream } from 'effect';
+import { Argument, Command, Flag } from 'effect/unstable/cli';
+import { ChildProcess, ChildProcessSpawner } from 'effect/unstable/process';
+import { RpcClient, RpcSerialization } from 'effect/unstable/rpc';
+import { Git } from './git.js';
+import { Notes } from './notes.js';
+import { NoteBatch, SidediffRpcs, Steps } from './protocol.js';
+import { Repo } from './repo.js';
+import { ServerInfo, freePort, serverLayer } from './server.js';
+class NoServer extends Schema.TaggedError()('NoServer', { serverFile: Schema.String }) {
+    get message() {
+        return 'no sidediff server is running for this repository; start one with `sidediff <range>`';
+    }
+}
+class BadLocation extends Schema.TaggedError()('BadLocation', { value: Schema.String }) {
+    get message() {
+        return `cannot read location ${this.value}, expected <file>[:line[-end]]`;
+    }
+}
+class Client extends Context.Service()('sidediff/Client') {
+    static layer = Layer.effect(Client, RpcClient.make(SidediffRpcs)).pipe(Layer.provide(RpcClient.layerProtocolSocket()), Layer.provide(Layer.unwrap(Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const { serverFile } = yield* Repo;
+        const info = yield* fs.readFileString(serverFile).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(ServerInfo))), Effect.mapError(() => new NoServer({ serverFile })));
+        return NodeSocket.layerWebSocket(`ws://${info.host}:${info.port}/rpc`);
+    }))), Layer.provide(RpcSerialization.layerNdjson));
+}
+const print = (value) => Console.log(JSON.stringify(value));
+const withClient = (effect) => Effect.provide(effect, Client.layer);
+const send = (command) => Client.use((client) => client.Send({ command })).pipe(Effect.flatMap(print), withClient);
+const location = Argument.String('location').pipe(Argument.withDescription('<file>[:line[-end]]'));
+const parseLocation = (value) => {
+    const match = /^(.+?)(?::(\d+)(?:-(\d+))?)?$/.exec(value);
+    if (match === null || match[1] === undefined)
+        return Effect.fail(new BadLocation({ value }));
+    const start = match[2] === undefined ? undefined : Number(match[2]);
+    const end = match[3] === undefined ? start : Number(match[3]);
+    return Effect.succeed({
+        file: match[1],
+        ...(start === undefined ? {} : { start }),
+        ...(end === undefined ? {} : { end }),
+    });
+};
+const side = Flag.Literals('side', ['old', 'new']).pipe(Flag.withDefault('new'), Flag.map((value) => (value === 'old' ? 'deletions' : 'additions')));
+const optionalText = (name) => Flag.String(name).pipe(Flag.optional, Flag.map(Option.getOrUndefined));
+const defined = (fields) => Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined));
+const speak = Flag.Boolean('speak').pipe(Flag.withDefault(false));
+const show = Command.make('show', { location, side }, ({ location, side }) => Effect.flatMap(parseLocation(location), (target) => send({ type: 'show', ...target, side }))).pipe(Command.withDescription('scroll the open view to <file>[:line[-end]]'));
+const highlight = Command.make('highlight', { location, side, text: optionalText('text') }, ({ location, side, text }) => Effect.flatMap(parseLocation(location), (target) => send({ type: 'highlight', ...target, side, ...defined({ text }) }))).pipe(Command.withDescription('select lines, optionally marking a substring'));
+const explain = Command.make('explain', { location, side, title: optionalText('title'), body: optionalText('body'), speak }, ({ location, side, title, body, speak }) => Effect.flatMap(parseLocation(location), (target) => send({ type: 'explain', ...target, side, speak, ...defined({ title, body }) }))).pipe(Command.withDescription('open a zoomed popover with an explanation'));
+const say = Command.make('say', { text: Argument.String('text').pipe(Argument.variadic({ min: 1 })), speak }, ({ text, speak }) => send({ type: 'say', text: text.join(' '), speak })).pipe(Command.withDescription('show a caption'));
+const clear = Command.make('clear', {}, () => send({ type: 'clear' })).pipe(Command.withDescription('remove highlights and popovers'));
+const tour = Command.make('tour', { steps: Argument.FileSchema('steps', Steps) }, ({ steps }) => send({ type: 'tour', steps })).pipe(Command.withDescription('load a guided tour from a JSON file of steps'));
+const next = Command.make('next', {}, () => send({ type: 'next' })).pipe(Command.withDescription('next tour step'));
+const back = Command.make('back', {}, () => send({ type: 'back' })).pipe(Command.withDescription('previous tour step'));
+const goto = Command.make('goto', { step: Argument.Int('step') }, ({ step }) => send({ type: 'goto', index: step - 1 })).pipe(Command.withDescription('jump to tour step <n>'));
+const where = Command.make('where', {}, () => Client.use((client) => client.View()).pipe(Effect.flatMap((view) => Console.log(JSON.stringify(view, null, 2))), withClient)).pipe(Command.withDescription('what the reader is looking at'));
+const listen = Command.make('listen', {
+    after: Flag.Int('after').pipe(Flag.optional, Flag.map(Option.getOrUndefined)),
+    wait: Flag.Int('wait').pipe(Flag.withDefault(600)),
+}, ({ after, wait }) => Effect.gen(function* () {
+    const client = yield* Client;
+    const heard = yield* client.Listen(after === undefined ? {} : { after }).pipe(Stream.take(1), Stream.runHead, Effect.timeoutOption(Duration.seconds(wait)), Effect.map(Option.flatten));
+    yield* Effect.forEach(Option.getOrElse(heard, () => []), (utterance) => Console.log(`${utterance.id}\t${utterance.text}`));
+}).pipe(withClient)).pipe(Command.withDescription('wait for the next thing said into the mic'));
+const noteAdd = Command.make('add', {
+    file: Flag.String('file'),
+    newLine: Flag.Int('new-line').pipe(Flag.optional, Flag.map(Option.getOrUndefined)),
+    oldLine: Flag.Int('old-line').pipe(Flag.optional, Flag.map(Option.getOrUndefined)),
+    summary: Flag.String('summary'),
+    rationale: optionalText('rationale'),
+    author: optionalText('author'),
+}, ({ file, newLine, oldLine, summary, rationale, author }) => Effect.gen(function* () {
+    const notes = yield* Notes;
+    const [note] = yield* notes.add([
+        { filePath: file, summary, ...defined({ newLine, oldLine, rationale, author }) },
+    ]);
+    yield* Console.log(`added ${note?.id} on ${note?.filePath}:${note?.line}`);
+})).pipe(Command.withDescription('add one note'));
+const noteApply = Command.make('apply', {}, () => Effect.gen(function* () {
+    const stdio = yield* Stdio.Stdio;
+    const notes = yield* Notes;
+    const text = yield* Stream.mkString(Stream.decodeText(stdio.stdin));
+    const batch = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(NoteBatch))(text);
+    const added = yield* notes.add('comments' in batch ? batch.comments : batch);
+    yield* Console.log(`added ${added.length} notes`);
+})).pipe(Command.withDescription('add a batch from stdin: {"comments":[{filePath,newLine|oldLine,summary,...}]}'));
+const noteList = Command.make('list', { json: Flag.Boolean('json').pipe(Flag.withDefault(false)), file: optionalText('file') }, ({ json, file }) => Effect.gen(function* () {
+    const notes = yield* Notes;
+    const shown = (yield* notes.list).filter((note) => file === undefined || note.filePath === file);
+    if (json)
+        return yield* Console.log(JSON.stringify(shown, null, 2));
+    yield* Effect.forEach(shown, (note) => Console.log(`${note.id}  ${note.filePath}:${note.line}  ${note.summary}`));
+})).pipe(Command.withDescription('list notes'));
+const noteRemove = Command.make('rm', { id: Argument.String('id') }, ({ id }) => Effect.gen(function* () {
+    const notes = yield* Notes;
+    yield* notes.remove(id);
+    yield* Console.log(`removed ${id}`);
+})).pipe(Command.withDescription('remove a note'));
+const noteClear = Command.make('clear', { file: optionalText('file') }, ({ file }) => Effect.gen(function* () {
+    const notes = yield* Notes;
+    const count = yield* notes.clear(file);
+    yield* Console.log(`cleared ${count} notes`);
+})).pipe(Command.withDescription('remove every note, or every note on one file'));
+const note = Command.make('note').pipe(Command.withDescription('notes live in <git dir>/sidediff/notes and appear in the browser as they are written'), Command.withSubcommands([noteAdd, noteApply, noteList, noteRemove, noteClear]));
+const openBrowser = (url) => ChildProcessSpawner.ChildProcessSpawner.use((spawner) => spawner.exitCode(process.platform === 'darwin'
+    ? ChildProcess.make('open', [url])
+    : process.platform === 'win32'
+        ? ChildProcess.make('cmd', ['/c', 'start', '', url])
+        : ChildProcess.make('xdg-open', [url]))).pipe(Effect.ignore);
+const sidediff = Command.make('sidediff', {
+    range: Argument.String('range').pipe(Argument.variadic()),
+    port: Flag.Int('port').pipe(Flag.withDefault(4977)),
+    host: Flag.String('host').pipe(Flag.withDefault('127.0.0.1')),
+    open: Flag.Boolean('open').pipe(Flag.withDefault(true)),
+    watch: Flag.Boolean('watch').pipe(Flag.withDefault(true)),
+}, ({ range, port, host, open, watch }) => Effect.gen(function* () {
+    const chosen = yield* freePort(port, host);
+    const url = `http://${host}:${chosen}`;
+    yield* Layer.launch(serverLayer({ range, port: chosen, host, watch }).pipe(Layer.merge(Layer.effectDiscard(Effect.andThen(Console.log(`sidediff: ${url}  (${watch ? 'watching for changes' : 'watch off'})`), open ? openBrowser(url) : Effect.void)))));
+})).pipe(Command.withDescription('GitHub-style diff review in the browser, with a live notes column'), Command.withSubcommands([note, show, highlight, explain, say, clear, tour, next, back, goto, where, listen]));
+const AppLayer = Notes.layer.pipe(Layer.provideMerge(Repo.layer), Layer.provideMerge(Git.layer), Layer.provideMerge(NodeServices.layer));
+Command.run(sidediff, { version: '0.2.0' }).pipe(Effect.provide(AppLayer), NodeRuntime.runMain);

package/dist/git.js

@@ -0,0 +1,42 @@
+import { Context, Effect, Layer, Schema, Stream } from 'effect';
+import { ChildProcess, ChildProcessSpawner } from 'effect/unstable/process';
+export class GitFailed extends Schema.TaggedError()('GitFailed', {
+    args: Schema.Array(Schema.String),
+    exitCode: Schema.Number,
+}) {
+}
+export class Git extends Context.Service()('sidediff/Git') {
+    static layer = Layer.effect(Git, Effect.gen(function* () {
+        const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const run = (cwd, args) => Effect.scoped(Effect.gen(function* () {
+            const handle = yield* spawner.spawn(ChildProcess.make('git', [...args], { cwd }));
+            const [stdout, exitCode] = yield* Effect.all([Stream.mkString(Stream.decodeText(handle.stdout)), handle.exitCode], { concurrency: 2 });
+            return exitCode === 0 ? stdout : yield* new GitFailed({ args, exitCode });
+        })).pipe(Effect.catchTag('PlatformError', () => Effect.fail(new GitFailed({ args, exitCode: -1 }))));
+        const trimmed = (cwd, args) => Effect.map(run(cwd, args), (out) => out.trim());
+        const sides = (cwd, range) => {
+            const [first, second] = range.filter((arg) => !arg.startsWith('-'));
+            if (first === undefined)
+                return Effect.succeed({ old: '', new: null });
+            if (first.includes('...')) {
+                const [base, head] = first.split('...');
+                const tip = head || 'HEAD';
+                return Effect.map(trimmed(cwd, ['merge-base', base || 'HEAD', tip]), (old) => ({ old, new: tip }));
+            }
+            if (first.includes('..')) {
+                const [base, head] = first.split('..');
+                return Effect.succeed({ old: base || 'HEAD', new: head || 'HEAD' });
+            }
+            return Effect.succeed({ old: first, new: second ?? null });
+        };
+        return {
+            run,
+            repoRoot: (cwd) => trimmed(cwd, ['rev-parse', '--show-toplevel']),
+            commonDir: (cwd) => trimmed(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']),
+            branch: (cwd) => trimmed(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']).pipe(Effect.orElseSucceed(() => 'HEAD')),
+            diff: (cwd, range) => run(cwd, ['-c', 'core.quotepath=false', 'diff', '--no-color', '--no-ext-diff', '--find-renames', ...range]),
+            sides,
+            show: (cwd, rev, path) => run(cwd, ['show', `${rev}:${path}`]),
+        };
+    }));
+}

package/dist/notes.js

@@ -0,0 +1,66 @@
+import { Context, DateTime, Effect, FileSystem, Layer, Option, Path, Random, Schema } from 'effect';
+import { Note } from './protocol.js';
+import { Repo } from './repo.js';
+export class NoteWithoutLine extends Schema.TaggedError()('NoteWithoutLine', {
+    filePath: Schema.String,
+}) {
+    get message() {
+        return `A note on ${this.filePath} needs a positive newLine or oldLine`;
+    }
+}
+export class NotesUnwritable extends Schema.TaggedError()('NotesUnwritable', {
+    directory: Schema.String,
+}) {
+    get message() {
+        return `cannot write notes in ${this.directory}`;
+    }
+}
+const decodeNote = Schema.decodeUnknownOption(Schema.fromJsonString(Note));
+const hex = (value) => value.toString(16).padStart(8, '0');
+export class Notes extends Context.Service()('sidediff/Notes') {
+    static layer = Layer.effect(Notes, Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const { notes: directory } = yield* Repo;
+        const unwritable = () => new NotesUnwritable({ directory });
+        const fileOf = (id) => path.join(directory, `${id}.json`);
+        const newId = Effect.map(Effect.all([Random.nextIntBetween(0, 0xffffffff), Random.nextIntBetween(0, 0xffffffff)]), ([a, b]) => `${hex(a)}${hex(b)}`);
+        const toNote = (input) => Effect.gen(function* () {
+            const line = input.newLine ?? input.oldLine;
+            if (line === undefined)
+                return yield* new NoteWithoutLine({ filePath: input.filePath });
+            const id = yield* newId;
+            const now = yield* DateTime.now;
+            return {
+                id,
+                filePath: input.filePath,
+                side: input.newLine === undefined ? 'deletions' : 'additions',
+                line,
+                summary: input.summary,
+                ...(input.rationale === undefined ? {} : { rationale: input.rationale }),
+                author: input.author ?? 'agent',
+                createdAt: DateTime.formatIso(now),
+            };
+        });
+        const list = Effect.gen(function* () {
+            const names = yield* fs.readDirectory(directory).pipe(Effect.orElseSucceed(() => []));
+            const read = yield* Effect.forEach(names.filter((name) => name.endsWith('.json')), (name) => fs.readFileString(path.join(directory, name)).pipe(Effect.map(decodeNote), Effect.orElseSucceed(() => Option.none())), { concurrency: 16 });
+            return read
+                .flatMap((note) => (Option.isSome(note) ? [note.value] : []))
+                .toSorted((a, b) => a.filePath.localeCompare(b.filePath) || a.line - b.line);
+        });
+        const remove = (id) => fs.remove(fileOf(id), { force: true }).pipe(Effect.mapError(unwritable));
+        const add = (inputs) => Effect.gen(function* () {
+            const created = yield* Effect.forEach(inputs, toNote);
+            yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.mapError(unwritable));
+            yield* Effect.forEach(created, (note) => fs.writeFileString(fileOf(note.id), JSON.stringify(note)).pipe(Effect.mapError(unwritable)), { concurrency: 16, discard: true });
+            return created;
+        });
+        const clear = (filePath) => Effect.gen(function* () {
+            const doomed = (yield* list).filter((note) => filePath === undefined || note.filePath === filePath);
+            yield* Effect.forEach(doomed, (note) => remove(note.id), { concurrency: 16, discard: true });
+            return doomed.length;
+        });
+        return { add, list, remove, clear };
+    }));
+}

package/dist/protocol.js

@@ -0,0 +1,91 @@
+import { Schema } from 'effect';
+import { Rpc, RpcGroup } from 'effect/unstable/rpc';
+export const Side = Schema.Literals(['additions', 'deletions']);
+const Line = Schema.Int.check(Schema.isGreaterThan(0));
+export const Note = Schema.Struct({
+    id: Schema.String,
+    filePath: Schema.String,
+    side: Side,
+    line: Line,
+    summary: Schema.String,
+    rationale: Schema.optionalKey(Schema.String),
+    author: Schema.String,
+    createdAt: Schema.String,
+});
+export const NoteInput = Schema.Struct({
+    filePath: Schema.NonEmptyString,
+    newLine: Schema.optionalKey(Line),
+    oldLine: Schema.optionalKey(Line),
+    summary: Schema.NonEmptyString,
+    rationale: Schema.optionalKey(Schema.String),
+    author: Schema.optionalKey(Schema.String),
+});
+export const NoteBatch = Schema.Union([
+    Schema.Array(NoteInput),
+    Schema.Struct({ comments: Schema.Array(NoteInput) }),
+]);
+export const Snapshot = Schema.Struct({
+    repo: Schema.String,
+    branch: Schema.String,
+    range: Schema.Array(Schema.String),
+    patch: Schema.String,
+    notes: Schema.Array(Note),
+    version: Schema.String,
+    watching: Schema.Boolean,
+    updatedAt: Schema.String,
+});
+const targetFields = {
+    file: Schema.String,
+    start: Schema.optionalKey(Line),
+    end: Schema.optionalKey(Line),
+    side: Side,
+    text: Schema.optionalKey(Schema.String),
+};
+export const Target = Schema.Struct(targetFields);
+const explanationFields = {
+    ...targetFields,
+    title: Schema.optionalKey(Schema.String),
+    body: Schema.optionalKey(Schema.String),
+};
+export const Explanation = Schema.Struct(explanationFields);
+export const Step = Schema.Union([
+    Schema.Struct({ type: Schema.Literal('show'), ...targetFields }),
+    Schema.Struct({ type: Schema.Literal('highlight'), ...targetFields }),
+    Schema.Struct({ type: Schema.Literal('explain'), speak: Schema.optionalKey(Schema.Boolean), ...explanationFields }),
+    Schema.Struct({ type: Schema.Literal('say'), text: Schema.String, speak: Schema.optionalKey(Schema.Boolean) }),
+    Schema.Struct({ type: Schema.Literal('clear') }),
+]);
+export const Steps = Schema.Array(Step);
+export const Command = Schema.Union([
+    Step,
+    Schema.Struct({ type: Schema.Literal('tour'), steps: Steps }),
+    Schema.Struct({ type: Schema.Literal('next') }),
+    Schema.Struct({ type: Schema.Literal('back') }),
+    Schema.Struct({ type: Schema.Literal('goto'), index: Schema.Int }),
+]);
+export const View = Schema.Struct({
+    file: Schema.NullOr(Schema.String),
+    activeNote: Schema.NullOr(Schema.String),
+    tourStep: Schema.NullOr(Schema.Int),
+    explaining: Schema.NullOr(Schema.String),
+});
+export const Utterance = Schema.Struct({
+    id: Schema.Int,
+    text: Schema.String,
+    at: Schema.String,
+    handled: Schema.Boolean,
+});
+export class FileMissing extends Schema.TaggedError()('FileMissing', {
+    side: Schema.Literals(['old', 'new']),
+    path: Schema.String,
+}) {
+}
+export const SidediffRpcs = RpcGroup.make(Rpc.make('Snapshots', { success: Snapshot, stream: true }), Rpc.make('File', {
+    payload: { side: Schema.Literals(['old', 'new']), path: Schema.NonEmptyString },
+    success: Schema.String,
+    error: FileMissing,
+}), Rpc.make('Send', { payload: { command: Command }, success: Schema.Struct({ delivered: Schema.Int }) }), Rpc.make('Commands', { success: Command, stream: true }), Rpc.make('ReportView', { payload: { view: View } }), Rpc.make('View', { success: Schema.NullOr(View) }), Rpc.make('Utter', { payload: { text: Schema.NonEmptyString, handled: Schema.Boolean }, success: Utterance }), Rpc.make('Listen', {
+    payload: { after: Schema.optionalKey(Schema.Int) },
+    success: Schema.Array(Utterance),
+    stream: true,
+}));

package/dist/repo.js

@@ -0,0 +1,12 @@
+import { Context, Effect, Layer, Path } from 'effect';
+import { Git } from './git.js';
+export class Repo extends Context.Service()('sidediff/Repo') {
+    static layer = Layer.effect(Repo, Effect.gen(function* () {
+        const git = yield* Git;
+        const path = yield* Path.Path;
+        const root = yield* git.repoRoot(process.cwd());
+        const common = yield* git.commonDir(root);
+        const state = path.join(common, 'sidediff');
+        return { root, notes: path.join(state, 'notes'), state, serverFile: path.join(state, 'server.json') };
+    }));
+}

package/dist/server.js

@@ -0,0 +1,139 @@
+import { createHash } from 'node:crypto';
+import { createServer } from 'node:http';
+import { createServer as createProbe } from 'node:net';
+import { fileURLToPath } from 'node:url';
+import { NodeHttpServer } from '@effect/platform-node';
+import { Context, DateTime, Duration, Effect, FileSystem, Layer, Path, PubSub, Ref, Schema, Stream, SubscriptionRef, } from 'effect';
+import { HttpRouter, HttpServerResponse } from 'effect/unstable/http';
+import { RpcSerialization, RpcServer } from 'effect/unstable/rpc';
+import { Git } from './git.js';
+import { Notes } from './notes.js';
+import { FileMissing, SidediffRpcs } from './protocol.js';
+import { Repo } from './repo.js';
+export class ServeOptions extends Context.Service()('sidediff/ServeOptions') {
+}
+export const ServerInfo = Schema.Struct({ port: Schema.Int, host: Schema.String, pid: Schema.Int });
+const ignoredSegments = new Set(['node_modules', 'dist', '.next', '.turbo', '.cache', 'coverage']);
+const isRelevant = (file) => {
+    const parts = file.split('/');
+    if (parts.some((part) => ignoredSegments.has(part)))
+        return false;
+    if (parts[0] !== '.git')
+        return true;
+    return file.includes('HEAD') || file.includes('refs') || file.endsWith('index');
+};
+const versionOf = (patch, notes) => createHash('sha1').update(patch).update(JSON.stringify(notes)).digest('hex').slice(0, 12);
+export class Review extends Context.Service()('sidediff/Review') {
+    static layer = Layer.effect(Review, Effect.gen(function* () {
+        const git = yield* Git;
+        const notes = yield* Notes;
+        const repo = yield* Repo;
+        const options = yield* ServeOptions;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const build = Effect.gen(function* () {
+            const [patch, current, branch, now] = yield* Effect.all([git.diff(repo.root, options.range), notes.list, git.branch(repo.root), DateTime.now], { concurrency: 'unbounded' });
+            return {
+                repo: repo.root,
+                branch,
+                range: options.range,
+                patch,
+                notes: current,
+                version: versionOf(patch, current),
+                watching: options.watch,
+                updatedAt: DateTime.formatIso(now),
+            };
+        });
+        const snapshot = yield* SubscriptionRef.make(yield* build);
+        const refresh = build.pipe(Effect.flatMap((next) => SubscriptionRef.update(snapshot, (current) => (current.version === next.version ? current : next))), Effect.catch((error) => Effect.logWarning('[refresh] diff failed', error)));
+        yield* fs.makeDirectory(repo.notes, { recursive: true });
+        const changes = Stream.merge(fs.watch(repo.notes), options.watch
+            ? fs.watch(repo.root, { recursive: true }).pipe(Stream.filter((event) => isRelevant(event.path)))
+            : Stream.empty);
+        yield* changes.pipe(Stream.debounce(Duration.millis(250)), Stream.runForEach(() => refresh), Effect.catch((error) => Effect.logWarning('[watch] stopped', error)), Effect.forkScoped);
+        const commands = yield* PubSub.unbounded();
+        const watchers = yield* Ref.make(0);
+        const views = yield* Ref.make(null);
+        const heard = yield* Ref.make([]);
+        const spoken = yield* PubSub.unbounded();
+        const file = (side, relative) => Effect.gen(function* () {
+            const missing = new FileMissing({ side, path: relative });
+            const inside = path.join(repo.root, relative);
+            if (path.relative(repo.root, inside).startsWith('..'))
+                return yield* missing;
+            const sides = yield* git.sides(repo.root, options.range).pipe(Effect.mapError(() => missing));
+            return side === 'new' && sides.new === null
+                ? yield* fs.readFileString(inside).pipe(Effect.mapError(() => missing))
+                : yield* git
+                    .show(repo.root, side === 'new' ? (sides.new ?? 'HEAD') : sides.old, relative)
+                    .pipe(Effect.mapError(() => missing));
+        });
+        const utter = (text, handled) => Effect.gen(function* () {
+            const now = yield* DateTime.now;
+            const utterance = yield* Ref.modify(heard, (all) => {
+                const next = { id: all.length + 1, text: text.trim(), at: DateTime.formatIso(now), handled };
+                return [next, [...all, next]];
+            });
+            if (!handled)
+                yield* PubSub.publish(spoken, utterance);
+            return utterance;
+        });
+        const listen = (after) => Stream.unwrap(Effect.map(Ref.get(heard), (all) => {
+            const since = after ?? all.length;
+            const pending = all.filter((utterance) => utterance.id > since && !utterance.handled);
+            const live = Stream.fromPubSub(spoken).pipe(Stream.filter((utterance) => utterance.id > since), Stream.map((utterance) => [utterance]));
+            return pending.length > 0 ? Stream.concat(Stream.make(pending), live) : live;
+        }));
+        return {
+            snapshots: SubscriptionRef.changes(snapshot),
+            file,
+            send: (command) => Effect.andThen(PubSub.publish(commands, command), Ref.get(watchers)),
+            commands: Stream.unwrap(Effect.as(Ref.update(watchers, (count) => count + 1), Stream.fromPubSub(commands).pipe(Stream.ensuring(Ref.update(watchers, (count) => count - 1))))),
+            reportView: (view) => Ref.set(views, view),
+            view: Ref.get(views),
+            utter,
+            listen,
+        };
+    }));
+}
+const RpcHandlers = SidediffRpcs.toLayer(Effect.gen(function* () {
+    const review = yield* Review;
+    return SidediffRpcs.of({
+        Snapshots: () => review.snapshots,
+        File: ({ side, path }) => review.file(side, path),
+        Send: ({ command }) => Effect.map(review.send(command), (delivered) => ({ delivered })),
+        Commands: () => review.commands,
+        ReportView: ({ view }) => review.reportView(view),
+        View: () => review.view,
+        Utter: ({ text, handled }) => review.utter(text, handled),
+        Listen: ({ after }) => review.listen(after),
+    });
+}));
+const webRoot = fileURLToPath(new URL('./web', import.meta.url));
+const StaticFiles = HttpRouter.add('GET', '/*', (request) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const pathname = new URL(request.url, 'http://localhost').pathname;
+    const asset = path.join(webRoot, pathname === '/' ? 'index.html' : pathname.slice(1));
+    if (path.relative(webRoot, asset).startsWith('..'))
+        return HttpServerResponse.empty({ status: 404 });
+    return yield* HttpServerResponse.file(asset, { headers: { 'cache-control': 'no-store' } }).pipe(Effect.orElseSucceed(() => HttpServerResponse.empty({ status: 404 })));
+}));
+const RpcRoute = RpcServer.layerHttp({ group: SidediffRpcs, path: '/rpc', protocol: 'websocket' }).pipe(Layer.provide(RpcHandlers), Layer.provide(RpcSerialization.layerNdjson));
+const portFree = (port, host) => Effect.callback((resume) => {
+    const probe = createProbe();
+    probe.once('error', () => resume(Effect.succeed(false)));
+    probe.listen(port, host, () => probe.close(() => resume(Effect.succeed(true))));
+});
+export const freePort = (start, host) => Effect.flatMap(portFree(start, host), (free) => (free ? Effect.succeed(start) : freePort(start + 1, host)));
+const Announce = Layer.effectDiscard(Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const repo = yield* Repo;
+    const options = yield* ServeOptions;
+    const info = { port: options.port, host: options.host, pid: process.pid };
+    yield* Effect.acquireRelease(fs.writeFileString(repo.serverFile, JSON.stringify(Schema.encodeSync(ServerInfo)(info))), () => fs.readFileString(repo.serverFile).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(ServerInfo))), Effect.flatMap((current) => current.pid === info.pid ? fs.remove(repo.serverFile, { force: true }) : Effect.void), Effect.ignore));
+}));
+export const serverLayer = (options) => HttpRouter.serve(Layer.mergeAll(RpcRoute, StaticFiles), { disableListenLog: true, disableLogger: true }).pipe(Layer.provide(Review.layer), Layer.merge(Announce), Layer.provide(NodeHttpServer.layer(createServer, {
+    port: options.port,
+    host: options.host,
+    gracefulShutdownTimeout: Duration.millis(300),
+})), Layer.provide(Layer.succeed(ServeOptions, options)));

package/dist/web/assets/abap-CLvhMVsD.js

@@ -0,0 +1 @@
+var e=[Object.freeze(JSON.parse(`{"displayName":"ABAP","fileTypes":["abap","ABAP"],"foldingStartMarker":"/\\\\*\\\\*|\\\\{\\\\s*$","foldingStopMarker":"\\\\*\\\\*/|^\\\\s*}","name":"abap","patterns":[{"captures":{"1":{"name":"punctuation.definition.comment.abap"}},"match":"^\\\\*.*\\\\n?","name":"comment.line.full.abap"},{"captures":{"1":{"name":"punctuation.definition.comment.abap"}},"match":"\\".*\\\\n?","name":"comment.line.partial.abap"},{"match":"(?<!\\\\S)##.*?(?=([,.:\\\\s]))","name":"comment.line.pragma.abap"},{"match":"(?i)(?<=[-~\\\\s])(?<=[-=]>)([/_a-z][/-9_a-z]*)(?=\\\\s+(?:|[-*+/]|&&?)=\\\\s+)","name":"variable.other.abap"},{"match":"\\\\b[0-9]+(\\\\b|[,.])","name":"constant.numeric.abap"},{"match":"(?i)(^|\\\\s+)((P(?:UBLIC|RIVATE|ROTECTED))\\\\sSECTION)(?=\\\\s+|[.:])","name":"storage.modifier.class.abap"},{"begin":"(?<!\\\\\\\\)(\\\\|)(.*?)","beginCaptures":{"1":{"name":"constant.character.escape.abap"}},"end":"(?<!\\\\\\\\)(\\\\||(\\\\\\\\\\\\\\\\\\\\|))","endCaptures":{"1":{"name":"constant.character.escape.abap"}},"name":"string.interpolated.abap","patterns":[{"match":"(\\\\{ )|( })","name":"constant.character.escape"},{"match":"\\\\\\\\\\\\|","name":"constant.character.escape.abap"},{"match":"(?i)(?<=\\\\s)(align|alpha|case|country|currency|date|decimals|exponent|number|pad|sign|style|time|timestamp|timezone|width|xsd|zero)(?=\\\\s=)","name":"entity.name.property.stringtemplate.abap"},{"match":"(?i)(?<==\\\\s)(center|engineering|environment|in|iso|left|leftplus|leftspace|lower|no|out|raw|right|rightplus|rightspace|scale_preserving|scale_preserving_scientific|scientific|scientific_with_leading_zero|sign_as_postfix|simple|space|upper|user|yes)(?=\\\\s)","name":"entity.value.property.stringtemplate.abap"}]},{"begin":"'","end":"'","name":"string.quoted.single.abap","patterns":[{"match":"''","name":"constant.character.escape.abap"}]},{"begin":"\`","end":"\`","name":"string.quoted.single.abap","patterns":[{"match":"\`\`","name":"constant.character.escape.abap"}]},{"begin":"(?i)^\\\\s*(class)\\\\s([/_a-z][/-9_a-z]*)","beginCaptures":{"1":{"name":"storage.type.block.abap"},"2":{"name":"entity.name.type.block.abap"}},"end":"\\\\s*\\\\.\\\\s*\\\\n?","name":"meta.block.begin.implementation.abap","patterns":[{"match":"(?i)(^|\\\\s+)(definition|implementation|public|inheriting\\\\s+from|final|deferred|abstract|shared\\\\s+memory\\\\s+enabled|(global|local)*\\\\s*friends|(create\\\\s+(p(?:ublic|rotected|rivate)))|for\\\\s+behavior\\\\s+of|for\\\\s+testing|risk\\\\s+level\\\\s+(critical|dangerous|harmless))|duration\\\\s(short|medium|long)(?=\\\\s+|\\\\.)","name":"storage.modifier.class.abap"},{"begin":"(?=[A-Z_a-z][0-9A-Z_a-z]*)","contentName":"entity.name.type.block.abap","end":"(?![0-9A-Z_a-z])","patterns":[{"include":"#generic_names"}]}]},{"begin":"(?i)^\\\\s*(method)\\\\s(?:([/_a-z][/-9_a-z]*)~)?([/_a-z][/-9_a-z]*)","beginCaptures":{"1":{"name":"storage.type.block.abap"},"2":{"name":"entity.name.type.abap"},"3":{"name":"entity.name.function.abap"}},"end":"\\\\s*\\\\.\\\\s*\\\\n?","patterns":[{"match":"(?i)(?<=^|\\\\s)(BY(?:\\\\s+DATABASE(\\\\s+PROCEDURE|\\\\s+FUNCTION|\\\\s+GRAPH\\\\s+WORKSPACE)|\\\\s+KERNEL\\\\s+MODULE))(?=\\\\s+|\\\\.)","name":"storage.modifier.method.abap"},{"match":"(?i)(?<=^|\\\\s)(FOR\\\\s+(HDB|LLANG))(?=\\\\s+|\\\\.)","name":"storage.modifier.method.abap"},{"match":"(?i)(?<=\\\\s)(OPTIONS\\\\s+(READ-ONLY|DETERMINISTIC|SUPPRESS\\\\s+SYNTAX\\\\s+ERRORS))(?=\\\\s+|\\\\.)","name":"storage.modifier.method.abap"},{"match":"(?i)(?<=^|\\\\s)(LANGUAGE\\\\s+(SQLSCRIPT|SQL|GRAPH))(?=\\\\s+|\\\\.)","name":"storage.modifier.method.abap"},{"captures":{"1":{"name":"storage.modifier.method.abap"}},"match":"(?i)(?<=\\\\s)(USING)\\\\s+([/_a-z][/-9=>_a-z]*)+(?=\\\\s+|\\\\.)"},{"begin":"(?=[A-Z_a-z][0-9A-Z_a-z]*)","end":"(?![0-9A-Z_a-z])","patterns":[{"include":"#generic_names"}]}]},{"begin":"(?i)^\\\\s*(INTERFACE)\\\\s([/_a-z][/-9_a-z]*)","beginCaptures":{"1":{"name":"storage.type.block.abap"},"2":{"name":"entity.name.type.abap"}},"end":"\\\\s*\\\\.\\\\s*\\\\n?","patterns":[{"match":"(?i)(?<=^|\\\\s)(DEFERRED|PUBLIC)(?=\\\\s+|\\\\.)","name":"storage.modifier.method.abap"}]},{"begin":"(?i)^\\\\s*(FORM)\\\\s([/_a-z][-/-9?_a-z]*)","beginCaptures":{"1":{"name":"storage.type.block.abap"},"2":{"name":"entity.name.type.abap"}},"end":"\\\\s*\\\\.\\\\s*\\\\n?","patterns":[{"match":"(?i)(?<=^|\\\\s)(USING|TABLES|CHANGING|RAISING|IMPLEMENTATION|DEFINITION)(?=\\\\s+|\\\\.)","name":"storage.modifier.form.abap"},{"include":"#abaptypes"},{"include":"#keywords_followed_by_braces"}]},{"match":"(?i)(end(?:class|method|form|interface))","name":"storage.type.block.end.abap"},{"match":"(?i)(<[A-Z_a-z][0-9A-Z_a-z]*>)","name":"variable.other.field.symbol.abap"},{"include":"#keywords"},{"include":"#abap_constants"},{"include":"#reserved_names"},{"include":"#operators"},{"include":"#builtin_functions"},{"include":"#abaptypes"},{"include":"#system_fields"},{"include":"#sql_functions"},{"include":"#sql_types"}],"repository":{"abap_constants":{"match":"(?i)(?<=\\\\s)(initial|null|@?space|@?abap_true|@?abap_false|@?abap_undefined|table_line|%_final|%_hints|%_predefined|col_background|col_group|col_heading|col_key|col_negative|col_normal|col_positive|col_total|adabas|as400|db2|db6|hdb|oracle|sybase|mssqlnt|pos_low|pos_high)(?=[,.\\\\s])","name":"constant.language.abap"},"abaptypes":{"patterns":[{"match":"(?i)\\\\s(abap_bool|string|xstring|any|clike|csequence|numeric|xsequence|decfloat|decfloat16|decfloat34|utclong|simple|int8|[cdfinptx])(?=[,.\\\\s])","name":"support.type.abap"},{"match":"(?i)\\\\s(TYPE|REF|TO|LIKE|LINE|OF|STRUCTURE|STANDARD|SORTED|HASHED|INDEX|TABLE|WITH|UNIQUE|NON-UNIQUE|SECONDARY|DEFAULT|KEY)(?=[,.\\\\s])","name":"keyword.control.simple.abap"}]},"arithmetic_operator":{"match":"(?i)(?<=\\\\s)([-*+]|\\\\*\\\\*|[%/]|DIV|MOD|BIT-AND|BIT-OR|BIT-XOR|BIT-NOT)(?=\\\\s)","name":"keyword.control.simple.abap"},"builtin_functions":{"match":"(?i)(?<=\\\\s)(abs|sign|ceil|floor|trunc|frac|acos|asin|atan|cos|sin|tan|cosh|sinh|tanh|exp|log|log10|sqrt|strlen|xstrlen|charlen|lines|numofchar|dbmaxlen|round|rescale|nmax|nmin|cmax|cmin|boolc|boolx|xsdbool|contains|contains_any_of|contains_any_not_of|matches|line_exists|ipow|char_off|count|count_any_of|count_any_not_of|distance|condense|concat_lines_of|escape|find|find_end|find_any_of|find_any_not_of|insert|match|repeat|replace|reverse|segment|shift_left|shift_right|substring|substring_after|substring_from|substring_before|substring_to|to_upper|to_lower|to_mixed|from_mixed|translate|bit-set|line_index)(?=\\\\()","name":"entity.name.function.builtin.abap"},"comparison_operator":{"match":"(?i)(?<=\\\\s)([<>]|<=|>=|=|<>|eq|ne|lt|le|gt|ge|cs|cp|co|cn|ca|na|ns|np|byte-co|byte-cn|byte-ca|byte-na|byte-cs|byte-ns|[moz])(?=\\\\s)","name":"keyword.control.simple.abap"},"control_keywords":{"match":"(?i)(^|\\\\s)(at|case|catch|continue|do|elseif|else|endat|endcase|endcatch|enddo|endif|endloop|endon|endtry|endwhile|if|loop|on|raise|try|while)(?=[.:\\\\s])","name":"keyword.control.flow.abap"},"generic_names":{"match":"[A-Z_a-z][0-9A-Z_a-z]*"},"keywords":{"patterns":[{"include":"#main_keywords"},{"include":"#text_symbols"},{"include":"#control_keywords"},{"include":"#keywords_followed_by_braces"}]},"keywords_followed_by_braces":{"captures":{"1":{"name":"keyword.control.simple.abap"},"2":{"name":"variable.other.abap"}},"match":"(?i)\\\\b(data|value|field-symbol|final|reference|resumable)\\\\((<?[/_a-z][/-9_a-z]*>?)\\\\)"},"logical_operator":{"match":"(?i)(?<=\\\\s)(not|or|and)(?=\\\\s)","name":"keyword.control.simple.abap"},"main_keywords":{"match":"(?i)(?<=^|\\\\s)(abap-source|abstract|accept|accepting|access|according|action|activation|actual|add|add-corresponding|adjacent|after|alias|aliases|all|allocate|amdp|analysis|analyzer|append|appending|application|archive|area|arithmetic|as|ascending|assert|assign|assigned|assigning|association|asynchronous|at|attributes|authority|authority-check|authorization|auto|back|background|backward|badi|base|before|begin|behavior|between|binary|bit|blanks??|blocks??|bound|boundaries|bounds|boxed|break|break-point|buffer|by|bypassing|byte|byte-order|call|calling|cast|casting|cds|centered|change|changing|channels|char-to-hex|character|check|checkbox|cid|circular|class|class-data|class-events|class-methods??|class-pool|cleanup|clear|clients??|clock|clone|close|cnt|code|collect|color|column|comments??|commit|common|communication|comparing|components??|compression|compute|concatenate|cond|condense|condition|connection|constants??|contexts??|controls??|conv|conversion|convert|copy|corresponding|count|country|cover|create|currency|current|cursor|customer-function|data|database|datainfo|dataset|date|daylight|ddl|deallocate|decimals|declarations|deep|default|deferred|define|delete|deleting|demand|descending|describe|destination|detail|determine|dialog|did|directory|discarding|display|display-mode|distance|distinct|divide|divide-corresponding|dummy|duplicates??|duration|during|dynpro|edit|editor-call|empty|enabled|enabling|encoding|end|end-enhancement-section|end-of-definition|end-of-page|end-of-selection|end-test-injection|end-test-seam|endenhancement|endexec|endfunction|endian|ending|endmodule|endprovide|endselect|endwith|enhancement|enhancement-point|enhancement-section|enhancements|entities|entity|entries|entry|enum|equiv|errors|escape|escaping|events??|exact|except|exception|exception-table|exceptions|excluding|exec|execute|exists|exit|exit-command|expanding|explicit|exponent|export|exporting|extended|extension|extract|fail|failed|features|fetch|field|field-groups|field-symbols|fields|file|fill|filters??|final|find|first|first-line|fixed-point|flush|following|for|format|forward|found|frames??|free|from|full|function|function-pool|generate|get|giving|graph|groups??|handler??|hashed|having|headers??|heading|help-id|help-request|hide|hint|hold|hotspot|icon|id|identification|identifier|ignore|ignoring|immediately|implemented|implicit|import|importing|in|inactive|incl|includes??|including|increment|index|index-line|indicators|infotypes|inheriting|init|initial|initialization|inner|input|insert|instances??|intensified|interface|interface-pool|interfaces|internal|intervals|into|inverse|inverted-date|is|job|join|keep|keeping|kernel|keys??|keywords|kind|language|last|late|layout|leading|leave|left|left-justified|legacy|length|let|levels??|like|line|line-count|line-selection|line-size|linefeed|lines|link|list|list-processing|listbox|load|load-of-program|locale??|locks??|log-point|logical|lower|mapped|mapping|margin|mark|mask|match|matchcode|maximum|members|memory|mesh|message|message-id|messages|messaging|methods??|mode|modif|modifier|modify|module|move|move-corresponding|multiply|multiply-corresponding|name|nametab|native|nested|nesting|new|new-line|new-page|new-section|next|no-display|no-extension|no-gaps??|no-grouping|no-heading|no-scrolling|no-sign|no-title|no-zero|nodes|non-unicode|non-unique|number|objects??|objmgr|obligatory|occurences??|occurrences??|occurs|of|offset|on|only|open|optional|options??|order|others|out|outer|output|output-length|overflow|overlay|pack|package|padding|page|parameter|parameter-table|parameters|part|partially|pcre|perform|performing|permissions|pf-status|places|pool|position|pragmas|preceding|precompiled|preferred|preserving|primary|print|print-control|private|privileged|procedure|process|program|property|protected|provide|push|pushbutton|put|query|queue-only|queueonly|quickinfo|radiobutton|raising|ranges??|read|read-only|received??|receiving|redefinition|reduce|ref|reference|refresh|regex|reject|renaming|replace|replacement|replacing|report|reported|request|requested|required|reserve|reset|resolution|respecting|response|restore|results??|resumable|resume|retry|return|returning|right|right-justified|rollback|rows|rp-provide-from-last|run|sap|sap-spool|save|saving|scan|screen|scroll|scroll-boundary|scrolling|search|seconds|section|select|select-options|selection|selection-screen|selection-sets??|selection-table|selections|send|separated??|session|set|shared|shift|shortdump|shortdump-id|sign|simple|simulation|single|size|skip|skipping|smart|some|sort|sortable|sorted|source|specified|split|spool|spots|sql|stable|stamp|standard|start-of-selection|starting|state|statements??|statics??|statusinfo|step|step-loop|stop|structures??|style|subkey|submatches|submit|subroutine|subscreen|substring|subtract|subtract-corresponding|suffix|sum|summary|supplied|supply|suppress|switch|symbol|syntax-check|syntax-trace|system-call|system-exceptions|tab|tabbed|tables??|tableview|tabstrip|target|tasks??|test|test-injection|test-seam|testing|text|textpool|then|throw|times??|title|titlebar|to|tokens|top-lines|top-of-page|trace-file|trace-table|trailing|transaction|transfer|transformation|translate|transporting|trmac|truncate|truncation|type|type-pools??|types|uline|unassign|unbounded|under|unicode|union|unique|unit|unix|unpack|until|unwind|up|update|upper|user|user-command|using|utf-8|uuid|valid|validate|value|value-request|values|vary|varying|version|via|visible|wait|when|where|windows??|with|with-heading|with-title|without|word|work|workspace|write|xml|zone)(?=[,.:\\\\s])","name":"keyword.control.simple.abap"},"operators":{"patterns":[{"include":"#other_operator"},{"include":"#arithmetic_operator"},{"include":"#comparison_operator"},{"include":"#logical_operator"}]},"other_operator":{"match":"(?<=\\\\s)(&&?|\\\\?=|\\\\+=|-=|/=|\\\\*=|&&=|&=)(?=\\\\s)","name":"keyword.control.simple.abap"},"reserved_names":{"match":"(?i)(?<=\\\\s)(me|super)(?=[,.\\\\s]|->)","name":"constant.language.abap"},"sql_functions":{"match":"(?i)(?<=\\\\s)(abap_system_timezone|abap_user_timezone|abs|add_days|add_months|allow_precision_loss|as_geo_json|avg|bintohex|cast|ceil|coalesce|concat_with_space|concat|corr_spearman|corr|count|currency_conversion|datn_add_days|datn_add_months|datn_days_between|dats_add_days|dats_add_months|dats_days_between|dats_from_datn|dats_is_valid|dats_tims_to_tstmp|dats_to_datn|dayname|days_between|dense_rank|division|div|extract_day|extract_hour|extract_minute|extract_month|extract_second|extract_year|first_value|floor|grouping|hextobin|initcap|instr|is_valid|lag|last_value|lead|left|length|like_regexpr|locate_regexpr_after|locate_regexpr|locate|lower|lpad|ltrim|max|median|min|mod|monthname|ntile|occurrences_regexpr|over|product|rank|replace_regexpr|replace|rigth|round|row_number|rpad|rtrim|stddev|string_agg|substring_regexpr|substring|sum|tims_from_timn|tims_is_valid|tims_to_timn|to_blob|to_clob|tstmp_add_seconds|tstmp_current_utctimestamp|tstmp_is_valid|tstmp_seconds_between|tstmp_to_dats|tstmp_to_dst|tstmp_to_tims|tstmpl_from_utcl|tstmpl_to_utcl|unit_conversion|upper|utcl_add_seconds|utcl_current|utcl_seconds_between|uuid|var|weekday)(?=\\\\()","name":"entity.name.function.sql.abap"},"sql_types":{"match":"(?i)(?<=\\\\s)(char|clnt|cuky|curr|datn|dats|dec|decfloat16|decfloat34|fltp|int1|int2|int4|int8|lang|numc|quan|raw|sstring|timn|tims|unit|utclong)(?=[()\\\\s])","name":"entity.name.type.sql.abap"},"system_fields":{"captures":{"1":{"name":"variable.language.abap"},"2":{"name":"variable.language.abap"}},"match":"(?i)\\\\b(sy)-(abcde|batch|binpt|calld|callr|colno|cpage|cprog|cucol|curow|datar|datlo|datum|dayst|dbcnt|dbnam|dbsysc|dyngr|dynnr|fdayw|fdpos|host|index|langu|ldbpg|lilli|linct|linno|linsz|lisel|listi|loopc|lsind|macol|mandt|marow|modno|msgid|msgli|msgno|msgty|msgv[1-4]|opsysc|pagno|pfkey|repid|saprl|scols|slset|spono|srows|staco|staro|stepl|subrc|sysid|tabix|tcode|tfill|timlo|title|tleng|tvar[0-9]|tzone|ucomm|uline|uname|uzeit|vline|wtitl|zonlo)(?=[.\\\\s])"},"text_symbols":{"captures":{"1":{"name":"keyword.control.simple.abap"},"2":{"name":"constant.numeric.abap"}},"match":"(?i)(?<=^|\\\\s)(text)-([0-9A-Z]{1,3})(?=[,.:\\\\s])"}},"scopeName":"source.abap"}`))];export{e as default};