JSDoc

mergeTheme(base: Theme, override: PartialTheme): Theme

ThemeProvider({ theme, themeOverride, children }: Props): ReactNode

useTheme(): Theme

Icon({ name, size, color, strokeWidth }: Props): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

Spinner({ size, thickness, tone, trackOpacity, }: Props): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

Chip({ label, tone, mono, leading, trailing, }: Props): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

Dot({ tone, size }: Props): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

Banner({ kind, title, children, icon, trailing }: Props): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

Button({ label, onPress, variant, size, disabled, leading, trailing, block, accessibilityLabel, }: Props): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

Card({ children, elevation, padding, borderColor, style, accent, }: Props): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

Skeleton({ width, height, radius, style, }: Props): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

ProgressBar({ ratio, tone, height }: Props): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

ConnectionPanel renders the full connection flow: 1. Provider radio (GitHub / Gitea / GitLab) 2. Auth sub-form (OAuth button or PAT input, per provider) 3. Custom host input (Gitea / GitLab) 4. Full Resource<T> shell on the auth attempt

ConnectionPanel({ model }: ConnectionPanelProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

RepoPickerSheet is a bottom-sheet style modal. List surface is derived from a single pickListSurface() helper that takes repos + filteredRepos + picked and returns one discriminated ListSurface. The RepoRow sub-component is extracted so consumers can wrap it with observer() to get per-row MobX reactivity.

RepoPickerSheet({ model }: RepoPickerSheetProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

RepoRow({ repo, isPicking, onSelect, theme, }: { readonly repo: RepoInfo; readonly isPicking: boolean; readonly onSelect: () => void; readonly theme: Theme; }): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

CreateRepoForm renders the "New repository" modal form. The form drives its submit button entirely through match(model.create).exhaustive() so all four Resource states have a distinct, visible affordance.

CreateRepoForm({ model }: CreateRepoFormProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

InitializationSequence({ model, repoLabel }: InitializationSequenceProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

InitStepRow({ step, theme }: InitStepRowProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

The SyncStatusBar derives its display surface from FOUR independent state inputs: - the sync Resource<T> (idle / loading / ready / error) - the connectivity union (online / offline / uncertain) - the categorised errorKind (when sync errored) - the expanded flag (whether the recovery panel is open) Offline overrides everything else — even a successful sync is misleading if the user has been disconnected since (their next mutation will queue). That's why the surface decision is a single `pickSurface()` function that takes all four inputs and returns one discriminated `Surface`.

SyncStatusBar({ model, nowISO }: SyncStatusBarProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

ConflictShell({ vm, getSides, renderPreview, viewport, drawerOpen: drawerOpenProp, }: ConflictShellProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

FileTreeRow({ file, isSelected, onSelect, onKeepMine, onKeepTheirs, theme, }: FileTreeRowProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

BranchGraph({ size, mine, theirs, mergeBase, maxDots }: BranchGraphProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

DivergenceExplainer({ model }: DivergenceExplainerProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

ConflictResolverSheet({ model, renderPreview, viewport, drawerOpen, }: ConflictResolverSheetProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

textPreviewForSides — the default preview for §4.6 text/markdown files. Shows side-by-side monospaced text panes (mine left, theirs right), with the active side highlighted. One column on phone (side switcher controls which side is visible). RN v1 fallback: plain monospace <Text> blocks, no syntax highlighting. On web, the consuming app can replace this with

TextPreview({ file, side, mine, theirs }: ConflictPreviewProps): ReactNode

RepoStateRecoveryPanel({ model }: RepoStateRecoveryPanelProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

FindingItem({ finding, theme }: FindingItemProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

ValidationFailureBanner({ model }: ValidationFailureBannerProps): any

FailureRow({ failure, model }: FailureRowProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

RepoStatusRow({ model }: RepoStatusRowProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

<T>({ state, label, onPress, variant, size, renderReady, }: IResourceButtonProps<T>): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

DiagnosticsSheet({ model }: DiagnosticsSheetProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

DiagnosticsRow({ entry, isExpanded, onToggle, theme }: DiagnosticsRowProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

ProviderSelector({ model, }: ProviderSelectorProps): import("/home/runner/work/gitapp/gitapp/node_modules/.pnpm/@types+react@18.3.28/node_modules/@types/react/jsx-runtime").JSX.Element

SyncStatusBadge — pure presentational indicator of git sync state. The `compact` variant renders a small inline badge suitable for the app chrome (top status row, header). The `expanded` variant renders a multi- line info panel suitable for a sheet or settings screen. Always pass `onPress` — dead UI is banned by CLAUDE.md. If the action isn't implemented yet, use warnNotImplemented in the caller.

SyncStatusBadge({ state, onPress, variant, }: SyncStatusBadgeProps): JSX.Element

EditorialBadge — pure presentational chip for the editorial state of a record. Not interactive (no onPress). If you need a tappable chip that drills into the review sheet, wrap this in a Pressable in the consuming component.

EditorialBadge({ state, size, tokens, }: EditorialBadgeProps): JSX.Element

ForkRepoButton — triggers a fork of `vm.source` to the user's account. Renders all four Resource states distinctly. The `ready` display auto-fades to idle after 2 s (without mutating the parent's Resource) so the user can fork again if needed.

ForkRepoButton({ vm }: ForkRepoButtonProps): JSX.Element

PullRequestComposer — sheet/modal for opening a PR. Supports two modes: - "editorial-submit": submitting a record for review (with optional scheduled-publish datetime). - "fork-back": proposing changes back to an upstream repo. All four Resource states on `vm.state` are rendered distinctly. The `ready` state auto-closes (calls onCancel) after 1 s so the user sees the success before the sheet dismisses.

PullRequestComposer({ vm }: PullRequestComposerProps): JSX.Element

EditorialQueueScreen — queue of content records by editorial state. Per-row observer pattern: EditorialQueueRowCard is extracted so MobX consumers can wrap individual rows with observer() without touching this file.

EditorialQueueScreen({ vm }: EditorialQueueScreenProps): JSX.Element

EditorialQueueRowCard({ row, onPress, }: EditorialQueueRowCardProps): JSX.Element

RecordReviewSheet — sheet for reviewing a single content record PR. Three footer actions: - Approve: merges/approves, each with its own Resource<void> state. - Request Changes: expands a comment input, then submits. - Close PR: closes without merging, with its own Resource<void> state. The renderPreview slot allows consuming apps to render domain-specific content (PPA: TaskCard, CMS: MarkdownArticle, etc.).

RecordReviewSheet({ vm, renderPreview, }: RecordReviewSheetProps): JSX.Element

PreviewPpaTask({ file, side, mine, theirs, mineTask, theirsTask, }: PreviewPpaTaskProps): ReactNode

PreviewCmsArticle({ file, side, mine, theirs, mineArticle, theirsArticle, frontmatterDiff, }: PreviewCmsArticleProps): ReactNode

PreviewBookmark({ file, side, mine, theirs, mineBookmark, theirsBookmark, }: PreviewBookmarkProps): ReactNode

PreviewPasswordEntry({ file, side, mine, theirs, mineEntry, theirsEntry, }: PreviewPasswordEntryProps): ReactNode

Returns true when the mode permits writes.

isWritable(mode: RepoMode): boolean

Human-readable description of the mode, exhaustive over all variants.

describeMode(mode: RepoMode): string

effectiveMode(selection: Pick<RepoSelection, "owner" | "name">, mode: RepoMode, demo: DemoRepoRef): RepoMode

requireWrite(mode: RepoMode, attemptedAction: string): WriteAccess

normalizeHost(provider: RepoProviderId, host: string): string

Human-readable description of a record's editorial state, exhaustive.

describeEditorialState(state: RecordEditorialState): string

Reads and validates the repo editorial config from `.gitapp/editorial.json`. - Returns `{ kind: "off" }` when the file is absent. - Returns `{ kind: "off" }` and calls `warnDegraded` on parse failure (forward-compat: unknown future variants fall through gracefully).

readEditorialConfig(source: EditorialConfigSource): Promise<RepoEditorialMode>

type Resource = Resource<T>

type ResourceT = Resource<T>

type Err = { readonly message: string; readonly cause?: unknown }

type StatusTone = | "neutral"
  | "brand"
  | "success"
  | "warn"
  | "danger"
  | "info"
  | "mine"
  | "theirs"
  | "merged"

type Connectivity = | { kind: "online" }
  | { kind: "offline" }
  | { kind: "uncertain" }

type ProviderId = "github" | "gitea" | "gitlab"

type IconName = | "check" | "x" | "alert" | "alertTri" | "info"
  | "chevronRight" | "chevronDown" | "chevronLeft" | "chevronUp"
  | "arrowRight" | "arrowLeft"
  | "refresh" | "rotate" | "search" | "plus" | "more" | "menu"
  | "lock" | "unlock" | "key"
  | "cloud" | "cloudOff" | "git" | "branch"
  | "folder" | "file" | "fileText" | "image"
  | "user" | "users" | "eye" | "eyeOff"
  | "download" | "upload" | "bookmark" | "bolt" | "trash"
  | "settings" | "activity" | "shield" | "wrench"
  | "circle" | "dot"

Categorised connection error so recovery copy can be specific.

type ConnectionErrorKind = | { kind: "auth"; reason: string }   // bad token / OAuth failure
  | { kind: "network" }                // unreachable
  | { kind: "not-found" }

Access state for a single repo — checked against current auth token.

type RepoAccess = | { kind: "found" }
  | { kind: "forbidden"; currentLogin: string }
  | { kind: "missing" }
  | { kind: "checking" }

Categorised create error — drives specific copy.

type CreateErrorKind = | { kind: "auth" }
  | { kind: "duplicate"; name: string }
  | { kind: "network" }
  | { kind: "unknown"; detail: string }

type InitStepState = | { kind: "pending" }
  | { kind: "running";  progress: InitStepProgress }
  | { kind: "ok";       durationMs: number }
  | { kind: "error";    message: string }
  | { kind: "blocked";  reason: string }

type InitStepProgress = | { kind: "indeterminate" }
  | { kind: "determinate"; ratio: number; label: string }

type InitOverall = | { kind: "running";  currentIndex: number }
  | { kind: "ok" }
  | { kind: "blocked";  failedIndex: number; error: string }

Categorised error so the recovery affordance can route appropriately.

type SyncErrorKind = | { kind: "auth" }                     // 401 / 403 → reconnect
  | { kind: "network" }                  // network unreachable
  | { kind: "conflict" }                 // non-fast-forward → opens Divergence
  | { kind: "rejected" }                 // server-side hook rejected
  | { kind: "unknown"; detail: string }

type ConflictSideId = "mine" | "theirs" | "merged"

type ConflictFileStatus = | { kind: "modifiedBoth" }
  | { kind: "modifiedMine" }
  | { kind: "modifiedTheirs" }
  | { kind: "deletedMine" }
  | { kind: "deletedTheirs" }
  | { kind: "addedMine" }
  | { kind: "addedTheirs" }
  | { kind: "renamed"; fromPath: string; toPath: string }
  | { kind: "binary" }

type ConflictFile = {
  readonly id: string;
  readonly path: string;
  readonly displayName: string;
  readonly status: ConflictFileStatus;
  readonly resolved: boolean;
}

type ConflictSide = | { kind: "text";    title: string; content: string }
  | { kind: "binary";  title: string; mimeType: string; sizeBytes: number }
  | { kind: "deleted"; title: string }
  | { kind: "missing"; title: string; reason: string }

type CommitSummary = {
  readonly id: string;
  readonly side: "mine" | "theirs";
  readonly shortHash: string;
  readonly title: string;
  readonly author: string;
  readonly whenISO: string;
}

type DivergedCommit = {
  readonly commitId: string;        // shown ONLY in "technical details" expand — never here
  readonly summary: string;         // plain-language label from summarizeCommit()
  readonly author: string;          // device name
  readonly whenISO: string;
}

type DivergedFileChange = {
  readonly path: string;
  readonly mineEdited: boolean;
  readonly theirsEdited: boolean;
  readonly bothEditedSameContent: boolean;
}

type ConflictDecision = | { kind: "pending" }
  | { kind: "keepMine" }
  | { kind: "keepTheirs" }
  | { kind: "merged"; content: string }
  | { kind: "deferred" }

A resolvable file as the resolver sees it — richer than the shell's ConflictFile (includes raw content + commit metadata + decision). The resolver maps this to the shell's ConflictFile via shellVm.files.

type ResolvableFile = {
  readonly path: string;
  readonly mine: {
    readonly content: string;
    readonly commit: string;
    readonly author: string;
    readonly whenISO: string;
  };
  readonly theirs: {
    readonly content: string;
    readonly commit: string;
    readonly author: string;
    readonly whenISO: string;
  };
  readonly decision: ConflictDecision;
}

type FindingPath = | { kind: "none" }
  | { kind: "some"; value: string }

type DiagnosisState = | { kind: "loading" }
  | { kind: "ready"; findings: Finding[] }

type LastGoodCommit = | { kind: "none" }
  | { kind: "some"; sha: string; whenISO: string }

type RepoStatusState = | { kind: "disconnected" }
  | { kind: "connectedNoRepo"; login: string }
  | { kind: "connected";       login: string; repo: { owner: string; name: string; branch: string } }
  | { kind: "connectedMismatch"; login: string; repo: { owner: string; name: string; branch: string } }
  | { kind: "checking";        login: string }

type DiagnosticsOp = "push" | "pull" | "commit" | "clone"

type DiagnosticsResult = | { kind: "ok";                detail: string }
  | { kind: "non-fast-forward";  detail: string }
  | { kind: "auth-error";        message: string }
  | { kind: "network";           message: string }
  | { kind: "rejected";          message: string }
  | { kind: "unknown";           message: string }

type DiagnosticsResultKind = | "ok"
  | "non-fast-forward"
  | "auth-error"
  | "network"
  | "rejected"
  | "unknown"

type DiagnosticsFilter = "all" | "errors" | "last-hour"

type SyncState = | { kind: "synced"; lastSyncedAt: number; sha: string }
  | { kind: "syncing"; phase: "push" | "pull" | "rebase"; sinceMs: number }
  | { kind: "ahead"; commits: number; sha: string }      // local has unpushed commits
  | { kind: "behind"; commits: number; sha: string }     // remote has unpulled commits
  | { kind: "diverged"; localCommits: number; remoteCommits: number }
  | { kind: "conflict"; files: ReadonlyArray<string> }
  | { kind: "offline"; lastSyncedAt: number }
  | { kind: "error"; error: { message: string }; tag: string }
  | { kind: "idle" }

Controls how much space the badge occupies.

type SyncStatusBadgeVariant = "compact" | "expanded"

type PullRequestComposerMode = | { kind: "editorial-submit"; recordTitle: string }
  | { kind: "fork-back"; sourceUpstream: { owner: string; name: string } }

type ScheduledPublish = | { kind: "none" }
  | { kind: "at"; iso: string }

type FrontmatterDiffLine = | { kind: "removed"; text: string }
  | { kind: "added";   text: string }
  | { kind: "context"; text: string }

RepoMode — discriminated union expressing the write-access level of a repo. - rw: user has full read-write access. - ro: user can only read. The `reason` field distinguishes the cause.

type RepoMode = | { kind: "rw" }
  | { kind: "ro"; reason: "no-access" | "demo" | "user-locked" }

type RepoProviderId = "github" | "gitea" | "gitlab"

type RoReason = | { readonly kind: "demo" }
  | { readonly kind: "no-access" }
  | { readonly kind: "user-locked" }

type WriteAccess = | { readonly kind: "granted" }
  | { readonly kind: "denied"; readonly reason: RoReason; readonly attemptedAction: string }

RecordEditorialState — the editorial lifecycle of a single content record. All variants are exhaustive — no null/undefined in the union.

type RecordEditorialState = | { kind: "published"; sha: string }
  | { kind: "draft"; branch: string; lastEdit: number; author: string }
  | {
      kind: "in-review";
      branch: string;
      pr: PullRequestRef;
      reviewers: ReadonlyArray<string>;
    }
  | { kind: "approved"; pr: PullRequestRef; readyToMerge: true }
  | {
      kind: "changes-requested";
      pr: PullRequestRef;
      reviewer: string;
      comment: string;
    }

RepoEditorialMode — the editorial workflow configured for the repo. - off: no editorial workflow; records are pushed to main directly. - branch-per-record: each record gets its own branch and PR. - single-working-branch: all drafts share one named branch. - open-authoring: forks from a specified upstream repo.

type RepoEditorialMode = | { kind: "off" }
  | { kind: "branch-per-record" }
  | { kind: "single-working-branch"; branch: string }
  | { kind: "open-authoring"; upstream: { owner: string; name: string } }

interface Theme

name: string

colors: ThemeColors

fonts: ThemeFonts

radii: ThemeRadii

spacing: ThemeSpacing

shadows: ThemeShadows

typography: ThemeTypography

interface ThemeColors

bg: string

surface: string

surface2: string

surface3: string

border: string

border2: string

text: string

text2: string

text3: string

text4: string

brand: string

brand2: string

brandFg: string

brandBg: string

success: string

successBg: string

successBorder: string

warn: string

warnBg: string

warnBorder: string

danger: string

dangerBg: string

dangerBorder: string

info: string

infoBg: string

infoBorder: string

mine: string

mineBg: string

mineBorder: string

theirs: string

theirsBg: string

theirsBorder: string

merged: string

mergedBg: string

mergedBorder: string

interface ThemeFonts

ui: string

mono: string

interface ThemeRadii

sm: number

md: number

lg: number

interface ThemeSpacing

xs: number

sm: number

md: number

lg: number

xl: number

interface ThemeShadow

color: string

opacity: number

offsetX: number

offsetY: number

radius: number

elevation: number

interface ThemeShadows

s1: ThemeShadow

s2: ThemeShadow

modal: ThemeShadow

interface ThemeTypography

t12: { size: number; lineHeight: number; weight: "400" | "500" | "600" | "700"; }

t13: { size: number; lineHeight: number; weight: "400" | "500" | "600" | "700"; }

t14: { size: number; lineHeight: number; weight: "400" | "500" | "600" | "700"; }

t15: { size: number; lineHeight: number; weight: "400" | "500" | "600" | "700"; }

t16: { size: number; lineHeight: number; weight: "400" | "500" | "600" | "700"; }

t18: { size: number; lineHeight: number; weight: "400" | "500" | "600" | "700"; }

t22: { size: number; lineHeight: number; weight: "400" | "500" | "600" | "700"; }

interface ConnectionPanelProps

model: IConnectionModel

interface IConnectionModel

provider: ProviderId

authMethod: { kind: "oauth"; } | { kind: "pat"; token: string; }

host: { kind: "default"; } | { kind: "custom"; url: string; }

connection: Resource<ConnectionSuccess>

errorKind: { kind: "none"; } | { kind: "some"; value: ConnectionErrorKind; }

onProviderChange(p: ProviderId): void

onAuthMethodChange(m: { kind: "oauth"; } | { kind: "pat"; token: string; }): void

onHostChange(h: { kind: "default"; } | { kind: "custom"; url: string; }): void

onConnect(): Promise<void>

onDisconnect(): Promise<void>

Connection success payload.

interface ConnectionSuccess

login: string

provider: ProviderId

interface RepoPickerSheetProps

model: IRepoPickerModel

interface IRepoPickerModel

repos: Resource<readonly RepoInfo[]>

filter: string

picked: { kind: "none"; } | { kind: "picking"; repo: RepoInfo; } | { kind: "picked"; repo: RepoInfo; }

currentLogin: { kind: "anonymous"; } | { kind: "loggedIn"; login: string; }

filteredRepos: readonly RepoInfo[]

canCreate: boolean

onFilterChange(v: string): void

onSelect(repo: RepoInfo): Promise<void>

onRefresh(): Promise<void>

onOpenCreate(): void

onDismiss(): void

Repo metadata returned from the provider's list-repos API.

interface RepoInfo

owner: string

name: string

isPrivate: boolean

defaultBranch: string

pushedAt: string

access: RepoAccess

interface CreateRepoFormProps

model: ICreateRepoModel

interface ICreateRepoModel

name: string

visibility: "private" | "public"

initWithReadme: boolean

create: Resource<CreatedRepo>

nameValidation: { kind: "ok"; } | { kind: "invalid"; reason: string; }

createErrorKind: { kind: "none"; } | { kind: "some"; value: CreateErrorKind; }

onNameChange(v: string): void

onVisibilityChange(v: "private" | "public"): void

onInitWithReadmeChange(v: boolean): void

onSubmit(): Promise<void>

onCancel(): void

Success payload — the created repo coordinates.

interface CreatedRepo

owner: string

name: string

interface InitializationSequenceProps

model: IInitModel

repoLabel: string

interface IInitModel

steps: readonly InitStep[]

overall: InitOverall

onRetry(stepId: string): Promise<void>

onReset(): Promise<void>

onCancel(): void

interface InitStep

id: string

label: string

state: InitStepState

interface InitStepRowProps

step: InitStep

theme: Theme

interface SyncStatusBarProps

model: ISyncStatusModel

nowISO: string

interface ISyncStatusModel

sync: Resource<SyncSummary>

connectivity: Connectivity

errorKind: { kind: "none"; } | { kind: "some"; value: SyncErrorKind; }

pendingCount: number

expanded: boolean

onToggleExpanded(): void

onRetry(): Promise<void>

onOpenDivergence(): void

onOpenDiagnostics(): void

onReconnect(): void

Successful-state payload — what the strip shows in `ready`.

interface SyncSummary

lastPushedISO: string

pendingCount: number

interface ConflictShellProps

vm: IConflictShellViewModel

getSides: (file: ConflictFile) => { mine: ConflictSide; theirs: ConflictSide; merged: ConflictSide; }

renderPreview: (props: ConflictPreviewProps) => ReactNode

viewport: "phone" | "desktop"

drawerOpen: boolean

interface IConflictShellViewModel

files: readonly ConflictFile[]

commits: readonly CommitSummary[]

selectedFile: { kind: "selected"; fileId: string; } | { kind: "none"; }

selectedSide: ConflictSideId

railMode: { kind: "files"; } | { kind: "commits"; }

resolvedCount: number

pendingCount: number

canApply: boolean

selectFile(fileId: string): void

selectSide(side: ConflictSideId): void

setRailMode(mode: IConflictShellViewModel["railMode"]): void

keepMine(fileId: string): void

keepTheirs(fileId: string): void

skip(fileId: string): void

apply(): Promise<void>

interface ConflictPreviewProps

file: ConflictFile

side: ConflictSideId

mine: ConflictSide

theirs: ConflictSide

merged: ConflictSide

interface FileTreeRowProps

file: ConflictFile

isSelected: boolean

onSelect: () => void

onKeepMine: () => void

onKeepTheirs: () => void

theme: Theme

interface BranchGraphProps

size: "phone" | "desktop" | "inline"

mine: readonly DivergedCommit[]

theirs: readonly DivergedCommit[]

mergeBase: { commitId: string; whenISO: string; }

maxDots: number

interface DivergenceExplainerProps

model: IDivergenceModel

interface IDivergenceModel

mine: readonly DivergedCommit[]

theirs: readonly DivergedCommit[]

mergeBase: { commitId: string; whenISO: string; }

fileChanges: readonly DivergedFileChange[]

strategy: { kind: "choosing"; } | { kind: "tryingAutomatic"; } | { kind: "automaticSucceeded"; } | { kind: "automaticFailed"; } | { kind: "confirmingDiscard"; side: "mine" | "theirs"; } | { kind: "discarding"; } | { kind: "discarded"; } | { kind: "applyError"; reason: string; }

canShowAutomatic: boolean

onTryAutomatic(): Promise<void>

onResolveManually(): void

onDiscard(side: "mine" | "theirs"): void

onConfirmDiscard(typed: string): Promise<void>

onCancel(): void

onShowTechnicalDetails(): void

interface ConflictResolverSheetProps

model: IConflictResolverModel

renderPreview: (props: ConflictPreviewProps) => ReactNode

viewport: "phone" | "desktop"

drawerOpen: boolean

interface IConflictResolverModel

files: readonly ResolvableFile[]

tab: "all" | "pending" | "resolved"

overall: { kind: "browsing"; } | { kind: "resolvingFile"; path: string; } | { kind: "applying"; } | { kind: "applied"; } | { kind: "applyError"; reason: string; }

pendingCount: number

resolvedCount: number

canApply: boolean

shellVm: IConflictShellViewModel

renderPreview(props: ConflictPreviewProps): ReactNode

onTabChange(tab: "all" | "pending" | "resolved"): void

onOpenFile(path: string): void

onCloseFile(): void

onDecide(path: string, decision: ConflictDecision): void

onKeepAllMine(): void

onKeepAllTheirs(): void

onApply(): Promise<void>

onDismiss(): void

interface RepoStateRecoveryPanelProps

model: IRecoveryModel

interface IRecoveryModel

repoOwner: string

repoName: string

lastWorkingISO: { kind: "none"; } | { kind: "some"; value: string; }

localChangesCount: number

diagnosis: DiagnosisState

recovery: Resource<RecoveryOutcome>

onSoftRefresh(): void

onPull(): Promise<void>

onReset(typedConfirmation: string): Promise<void>

onOpenDiagnostics(): void

onSwitchRepo(): void

interface Finding

severity: "warn" | "error"

message: string

path: FindingPath

Outcome returned by successful recovery operations.

interface RecoveryOutcome

message: string

interface ValidationFailureBannerProps

model: IValidationModel

interface IValidationModel

failures: Resource<ValidationFailure[]>

onShowDetails(file: string): void

onOpenRawEditor(file: string): void

onReset(file: string): void

onDismiss(file: string): void

interface ValidationFailure

path: string

oneLineError: string

fullErrors: readonly string[]

lastGoodCommit: LastGoodCommit

interface FailureRowProps

failure: ValidationFailure

model: IValidationModel

interface RepoStatusRowProps

model: IRepoStatusModel

interface IRepoStatusModel

state: RepoStatusState

onPress(): void

interface IResourceButtonProps

state: Resource<T>

label: string

onPress: (() => void) | (() => Promise<void>)

variant: "danger" | "primary" | "secondary"

size: "sm" | "md" | "lg"

renderReady: (value: T) => ReactNode

interface DiagnosticsSheetProps

model: IDiagnosticsModel

interface IDiagnosticsModel

entries: Resource<DiagnosticsEntry[]>

filter: DiagnosticsFilter

expanded: { kind: "none"; } | { kind: "some"; entryId: string; }

onFilterChange(filter: DiagnosticsFilter): void

onToggleExpanded(id: string): void

onClear(): void

onExport(): void

interface DiagnosticsEntry

id: string

whenISO: string

op: DiagnosticsOp

result: DiagnosticsResult

durationMs: number

args: Record<string, unknown>

interface DiagnosticsRowProps

entry: DiagnosticsEntry

isExpanded: boolean

onToggle: () => void

theme: Theme

interface ProviderSelectorProps

model: IProviderSelectorModel

interface IProviderSelectorModel

current: { provider: ProviderId; host: string; }

state: Resource<void>

isOpen: boolean

onSelectProvider(provider: ProviderId): void

onCustomHostChange(host: string): void

onConfirm(): Promise<void>

onDismiss(): void

interface SyncStatusBadgeProps

state: SyncState

onPress: (state: SyncState) => void

variant: SyncStatusBadgeVariant

tokens: Partial<{ accent: string; accentFg: string; success: string; warn: string; danger: string; text: string; text2: string; text3: string; surface: string; border: string; warnBg: string; dangerBg: string; successBg: string; }>

interface EditorialBadgeProps

state: RecordEditorialState

size: "sm" | "md"

tokens: EditorialBadgeTokens

interface EditorialBadgeTokens

draft: string

inReview: string

approved: string

changesRequested: string

published: string

interface ForkRepoButtonProps

vm: ForkRepoViewModel

interface ForkRepoViewModel

source: { owner: string; name: string; }

state: Resource<{ owner: string; name: string; }>

onPress(): void

interface PullRequestComposerProps

vm: PullRequestComposerViewModel

interface PullRequestComposerViewModel

mode: PullRequestComposerMode

title: string

body: string

baseBranch: string

scheduledPublish: ScheduledPublish

state: Resource<PullRequestRef>

onChangeTitle(s: string): void

onChangeBody(s: string): void

onChangeBaseBranch(s: string): void

onChangeScheduled(s: ScheduledPublish): void

onSubmit(): void

onCancel(): void

interface EditorialQueueScreenProps

vm: EditorialQueueViewModel

interface EditorialQueueViewModel

rows: readonly EditorialQueueRow[]

filter: EditorialQueueFilter

layout: "kanban" | "list"

state: Resource<void>

onSelectRow(id: string): void

onChangeFilter(filter: EditorialQueueFilter): void

onToggleLayout(): void

interface EditorialQueueRow

id: string

title: string

state: RecordEditorialState

author: string

updatedAt: number

interface EditorialQueueFilter

state: readonly ("published" | "draft" | "in-review" | "approved" | "changes-requested")[]

author: string

interface EditorialQueueRowCardProps

row: EditorialQueueRow

onPress: (id: string) => void

interface RecordReviewSheetProps

vm: RecordReviewSheetViewModel

renderPreview: (record: { rawContent: string; meta: unknown; }) => ReactNode

interface RecordReviewSheetViewModel

record: { readonly id: string; readonly title: string; readonly rawContent: string; readonly meta: unknown; }

pr: PullRequestRef

approveState: Resource<void>

requestChangesState: Resource<{ comment: string; }>

closeState: Resource<void>

onApprove(): void

onRequestChanges(comment: string): void

onClose(): void

onCancel(): void

interface PreviewPpaTaskProps

mineTask: PpaTaskRecord

theirsTask: PpaTaskRecord

interface PpaTaskRecord

title: string

status: string

context: string

project: string

due: string

body: string

author: string

whenLabel: string

interface PreviewCmsArticleProps

mineArticle: CmsArticleRecord

theirsArticle: CmsArticleRecord

frontmatterDiff: readonly FrontmatterDiffLine[]

interface CmsArticleRecord

title: string

slug: string

publishedAt: string

authors: readonly string[]

tags: readonly string[]

draft: boolean

body: string

author: string

whenLabel: string

interface PreviewBookmarkProps

mineBookmark: BookmarkRecord

theirsBookmark: BookmarkRecord

interface BookmarkRecord

id: string

url: string

title: string

tags: readonly string[]

notes: string

addedAt: string

whenLabel: string

interface PreviewPasswordEntryProps

mineEntry: PasswordRecord

theirsEntry: PasswordRecord

interface PasswordRecord

accountName: string

username: string

passwordMasked: true

has2FaSeed: boolean

url: string

notes: string

whenLabel: string

deviceLabel: string

interface RepoSelection

providerId: RepoProviderId

owner: string

name: string

provider: RepoProviderId

host: string

interface DemoRepoRef

owner: string

name: string

PullRequestRef — minimal PR reference mirroring the shape Track 3 uses in

interface PullRequestRef

number: number

state: "merged" | "open" | "closed"

title: string

htmlUrl: string

Provider-agnostic file-reading interface. PPA wires the iso-git read in later; tests inject a fake.

interface EditorialConfigSource

readFile(path: string): Promise<string | null>

const defaultLightTheme: Theme

Zod schema for RepoMode. Uses .passthrough() for forward-compatibility — unknown fields are preserved rather than rejected. Never uses .optional() — missing fields signal a parse failure.

const RepoModeSchema: z.ZodType<RepoMode, z.ZodTypeDef, RepoMode>

const ProviderIdSchema: z.ZodType<RepoProviderId, z.ZodTypeDef, RepoProviderId>

const RepoSelectionSchema: z.ZodType<RepoSelection, z.ZodTypeDef, RepoSelection>

Zod schema for RecordEditorialState. Uses .passthrough() on each variant for forward-compatibility.

const RecordEditorialStateSchema: z.ZodType<RecordEditorialState, z.ZodTypeDef, RecordEditorialState>

Zod schema for RepoEditorialMode. Uses .passthrough() on each variant for forward-compatibility.

const RepoEditorialModeSchema: z.ZodType<RepoEditorialMode, z.ZodTypeDef, RepoEditorialMode>

Zod schema for PullRequestRef.

const PullRequestRefSchema: z.ZodType<PullRequestRef, z.ZodTypeDef, PullRequestRef>