gutterpress 0.0.0

package/dist/index.js

@@ -0,0 +1,310 @@
+import {
+  APP_HEARTBEAT_FRESH_MS,
+  AUTO_SNAPSHOT_DEFAULT_MINUTES,
+  AUTO_SNAPSHOT_MAX_MINUTES,
+  AUTO_SNAPSHOT_MIN_MINUTES,
+  AUTO_SYNC_DEFAULT_MINUTES,
+  AUTO_SYNC_MAX_MINUTES,
+  AUTO_SYNC_MIN_MINUTES,
+  BUILT_IN_TEMPLATE_IDS,
+  BUILT_IN_THEME_IDS,
+  BuildError,
+  FileTokenStore,
+  GITHUB_HOST,
+  GenericTokenAuthProvider,
+  GitHubAuthProvider,
+  MANIFEST_FILENAMES,
+  PLUGINS_DIR,
+  PublishSelectionsStore,
+  RECOMMENDED_PLUGINS,
+  RepoNeedsRecoveryError,
+  SNIPPETS_DIR,
+  SYNC_SNAPSHOT_MESSAGE,
+  THEMES_DIR,
+  addLocalPlugin,
+  addNpmPlugin,
+  adoptFolder,
+  appHeartbeatPath,
+  applyTheme,
+  autoSnapshotDelayMs,
+  autoSyncDelayMs,
+  buildPreflightDiagnostics,
+  buildRecoveryContext,
+  checkCss,
+  checkToolAvailability,
+  classifyFromHealth,
+  classifyGitError,
+  cloneRepository,
+  connectGenericHost,
+  connectPublishProvider,
+  defaultConfigDir,
+  deleteSnippet,
+  diagnoseProjectRemote,
+  escapeYamlScalar,
+  executeAndReport,
+  executeValidation,
+  extractUrlCredential,
+  extractVariables,
+  forgeKindForHost,
+  formatReport,
+  getActiveTheme,
+  getCheckById,
+  getChecks,
+  getPreviousTheme,
+  getSystemDiagnostics,
+  hasProjectManifest,
+  heartbeatTtlMs,
+  importTemplateFromFolder,
+  importThemeFromFile,
+  importThemeFromFolder,
+  importThemeFromUrl,
+  inspectImage,
+  inspectRepo,
+  isAppHeartbeatFresh,
+  isGitInternalPath,
+  isRepoNeedsRecoveryError,
+  isSshRemoteUrl,
+  isUnbornRepo,
+  knownForgeTokenUrl,
+  listBuiltInTemplates,
+  listBuiltInThemes,
+  listCustomTemplates,
+  listGitHubBranches,
+  listGitHubRepositories,
+  listProjectPlugins,
+  listProjectStyles,
+  listProjectThemes,
+  listPublishAccounts,
+  listPublishProviders,
+  listRepoBooks,
+  listSnippets,
+  loadManifest,
+  loadManifestWithPath,
+  log,
+  migrateUrlCredential,
+  normalizeForgeHost,
+  onlineCopyPath,
+  openPath,
+  parseRemoteOrigin,
+  preflightStructuralReason,
+  provenancePath,
+  publishConnectionStatus,
+  publishCredentialKey,
+  publishProviderFor,
+  pullChanges,
+  pushChanges,
+  readAppHeartbeat,
+  readManifestFields,
+  readProjectProvenance,
+  readPublishSettings,
+  readSnippet,
+  readThemeCss,
+  recover,
+  redactCredential,
+  removeAppHeartbeat,
+  removeProjectTheme,
+  reportMissingTools,
+  resolveActiveStyles,
+  resolveBuiltInTheme,
+  resolveCheckSelectors,
+  resolveConfig,
+  resolveConflicts,
+  resolveGitHubClientId,
+  resolvePublishRequest,
+  revertTheme,
+  rulePagedjsCrashSelectors,
+  ruleRemoteUrls,
+  ruleRiskyProps,
+  ruleSyntax,
+  runBuild,
+  runChecks,
+  runLint,
+  runPublish,
+  sanitizeCloneFolderName,
+  saveProjectAsTemplate,
+  saveSnippet,
+  scaffoldProject,
+  setActiveStyles,
+  setManifestFields,
+  setPluginEnabled,
+  setPublishProviderConfig,
+  slugifyProjectName,
+  splitOutPath,
+  startPreviewServer,
+  substituteVariables,
+  syncProject,
+  testRemoteAccess,
+  validateProjectPlugins,
+  verifyRepoReadable,
+  writeAppHeartbeat
+} from "./index-3h3fef7r.js";
+import {
+  AUTO_SNAPSHOT_MESSAGE,
+  HISTORY_PAGE_LIMIT,
+  RESTORE_BACKUP_MESSAGE,
+  isNoChangesError,
+  providerFor,
+  resolveLogger,
+  restoreVersionWithBackup,
+  shortOid
+} from "./index-5bxx0c4y.js";
+import {
+  capabilitiesFor,
+  detectProjectSource,
+  findEnclosingRepoDir,
+  repoSubPath
+} from "./index-1tyj4bk3.js";
+import"./index-yja077f6.js";
+import"./index-37x76zdn.js";
+export {
+  writeAppHeartbeat,
+  verifyRepoReadable,
+  validateProjectPlugins,
+  testRemoteAccess,
+  syncProject,
+  substituteVariables,
+  startPreviewServer,
+  splitOutPath,
+  slugifyProjectName,
+  shortOid,
+  setPublishProviderConfig,
+  setPluginEnabled,
+  setManifestFields,
+  setActiveStyles,
+  scaffoldProject,
+  saveSnippet,
+  saveProjectAsTemplate,
+  sanitizeCloneFolderName,
+  runPublish,
+  runLint,
+  runChecks,
+  runBuild,
+  ruleSyntax,
+  ruleRiskyProps,
+  ruleRemoteUrls,
+  rulePagedjsCrashSelectors,
+  revertTheme,
+  restoreVersionWithBackup,
+  resolvePublishRequest,
+  resolveLogger,
+  resolveGitHubClientId,
+  resolveConflicts,
+  resolveConfig,
+  resolveCheckSelectors,
+  resolveBuiltInTheme,
+  resolveActiveStyles,
+  reportMissingTools,
+  repoSubPath,
+  removeProjectTheme,
+  removeAppHeartbeat,
+  redactCredential,
+  recover,
+  readThemeCss,
+  readSnippet,
+  readPublishSettings,
+  readProjectProvenance,
+  readManifestFields,
+  readAppHeartbeat,
+  pushChanges,
+  pullChanges,
+  publishProviderFor,
+  publishCredentialKey,
+  publishConnectionStatus,
+  providerFor,
+  provenancePath,
+  preflightStructuralReason,
+  parseRemoteOrigin,
+  openPath,
+  onlineCopyPath,
+  normalizeForgeHost,
+  migrateUrlCredential,
+  log,
+  loadManifestWithPath,
+  loadManifest,
+  listSnippets,
+  listRepoBooks,
+  listPublishProviders,
+  listPublishAccounts,
+  listProjectThemes,
+  listProjectStyles,
+  listProjectPlugins,
+  listGitHubRepositories,
+  listGitHubBranches,
+  listCustomTemplates,
+  listBuiltInThemes,
+  listBuiltInTemplates,
+  knownForgeTokenUrl,
+  isUnbornRepo,
+  isSshRemoteUrl,
+  isRepoNeedsRecoveryError,
+  isNoChangesError,
+  isGitInternalPath,
+  isAppHeartbeatFresh,
+  inspectRepo,
+  inspectImage,
+  importThemeFromUrl,
+  importThemeFromFolder,
+  importThemeFromFile,
+  importTemplateFromFolder,
+  heartbeatTtlMs,
+  hasProjectManifest,
+  getSystemDiagnostics,
+  getPreviousTheme,
+  getChecks,
+  getCheckById,
+  getActiveTheme,
+  formatReport,
+  forgeKindForHost,
+  findEnclosingRepoDir,
+  extractVariables,
+  extractUrlCredential,
+  executeValidation,
+  executeAndReport,
+  escapeYamlScalar,
+  diagnoseProjectRemote,
+  detectProjectSource,
+  deleteSnippet,
+  defaultConfigDir,
+  connectPublishProvider,
+  connectGenericHost,
+  cloneRepository,
+  classifyGitError,
+  classifyFromHealth,
+  checkToolAvailability,
+  checkCss,
+  capabilitiesFor,
+  buildRecoveryContext,
+  buildPreflightDiagnostics,
+  autoSyncDelayMs,
+  autoSnapshotDelayMs,
+  applyTheme,
+  appHeartbeatPath,
+  adoptFolder,
+  addNpmPlugin,
+  addLocalPlugin,
+  THEMES_DIR,
+  SYNC_SNAPSHOT_MESSAGE,
+  SNIPPETS_DIR,
+  RepoNeedsRecoveryError,
+  RESTORE_BACKUP_MESSAGE,
+  RECOMMENDED_PLUGINS,
+  PublishSelectionsStore,
+  PLUGINS_DIR,
+  MANIFEST_FILENAMES,
+  HISTORY_PAGE_LIMIT,
+  GitHubAuthProvider,
+  GenericTokenAuthProvider,
+  GITHUB_HOST,
+  FileTokenStore,
+  BuildError,
+  BUILT_IN_THEME_IDS,
+  BUILT_IN_TEMPLATE_IDS,
+  AUTO_SYNC_MIN_MINUTES,
+  AUTO_SYNC_MAX_MINUTES,
+  AUTO_SYNC_DEFAULT_MINUTES,
+  AUTO_SNAPSHOT_MIN_MINUTES,
+  AUTO_SNAPSHOT_MESSAGE,
+  AUTO_SNAPSHOT_MAX_MINUTES,
+  AUTO_SNAPSHOT_DEFAULT_MINUTES,
+  APP_HEARTBEAT_FRESH_MS
+};

package/dist/lib/app-heartbeat.d.ts

@@ -0,0 +1,102 @@
+/**
+  * app-heartbeat.ts — detect a running Gutterpress app before a CLI repair
+ * mutates the repo.
+ *
+ * WHY: `gutterpress repair` and the desktop's own recovery path both call into
+ * the recovery subsystem, but each runs in its own OS process. The per-repo
+ * FIFO lock (source-provider.ts) only serializes operations WITHIN a process,
+ * so `gutterpress repair` run from a terminal while the desktop has the same
+ * project open can race a live sync/snapshot. Rather than build a
+ * cross-process lock manager, the desktop leaves a small liveness marker
+ * behind while a project is open, and `repair` checks it before mutating.
+ *
+ * The marker lives at `<repoDir>/.git/gutterpress-app-heartbeat` (NOT in
+ * userData) so `repair`, given only a repo directory, can find it without any
+ * knowledge of the desktop's install. It is deliberately NOT a lock:
+ *   - It never blocks the desktop itself, or any other repair run with --force.
+ *   - It carries no locking semantics — just "an app touched this repo
+ *     recently, maybe check before you assume it's idle".
+ *   - It is written best-effort (a failed write must never surprise the
+ *     author with a crash) and read best-effort (a missing/corrupt file
+ *     means "no app appears to have this open", not an error).
+ *
+ * Two invariants that keep this file inert to the rest of the recovery
+ * subsystem:
+ *   - Filename does not match any pattern `findLockCandidates` scans
+ *     (recover-stale-lock.ts: fixed top-level `*.lock` names + `refs/**`) —
+ *     so stale-lock recovery can never see or remove it.
+ *   - It lives under `.git`, which `hasPendingChanges`/`listWorkdirChanges`
+ *     (source-provider.ts) always ignores (`git.isIgnored` treats a `.git`
+ *     path segment as ignored unconditionally) — so it can never look like an
+ *     uncommitted author change.
+ */
+/**
+ * Fallback freshness window used only when a heartbeat carries no `ttlMs`
+ * (an older writer, or one with no cadence to report). Prefer a
+ * cadence-derived TTL — see {@link heartbeatTtlMs} — since the actual
+ * refresh cadence ranges 1 min–24 h (AUTO_SYNC_MIN/MAX_MINUTES,
+ * host-policy.ts) and a fixed 2-minute window reads a live app as "closed"
+ * for most of any longer cadence.
+ */
+export declare const APP_HEARTBEAT_FRESH_MS: number;
+export interface AppHeartbeat {
+    /** PID of the process that wrote the heartbeat (diagnostic only — never
+     *  used to `kill`/signal anything). */
+    pid: number;
+    /** Epoch ms the heartbeat was last (re)written. */
+    timestamp: number;
+    /**
+     * Freshness window (ms) the writer says applies to THIS heartbeat, derived
+     * from its own refresh cadence (see {@link heartbeatTtlMs}). When present,
+     * `isAppHeartbeatFresh` honors it instead of its `maxAgeMs` fallback param —
+     * the writer knows how often it actually refreshes; the reader doesn't.
+     */
+    ttlMs?: number;
+}
+/**
+ * The freshness window a heartbeat writer should stamp for a given refresh
+ * cadence (the actual interval this writer refreshes the marker on — e.g.
+ * `autoSyncDelayMs(settings.versionHistory)`). `null` (feature disabled, no
+ * periodic refresh at all) falls back to {@link APP_HEARTBEAT_FRESH_MS}.
+ *
+ * Standard heartbeat rule: TTL should comfortably exceed the refresh period
+ * so one missed/delayed tick doesn't read as "closed". Exported so both the
+ * desktop (the writer, which knows its own cadence) and tests can compute it
+ * consistently.
+ */
+export declare function heartbeatTtlMs(periodicMs: number | null): number;
+/** Absolute path to the heartbeat marker for a repo. */
+export declare function appHeartbeatPath(repoDir: string): string;
+/**
+ * Write/refresh the heartbeat marker. Best-effort: a failed write (missing
+ * `.git` dir, read-only filesystem, …) is swallowed — it must never surface
+ * as an error to the author, since it is only ever a background liveness
+ * signal, not a required operation.
+ *
+ * `ttlMs`, when supplied, should be {@link heartbeatTtlMs} applied to this
+ * writer's OWN actual refresh cadence — it is stamped into the marker so a
+ * reader with no knowledge of that cadence still judges freshness correctly.
+ * Omit it (or pass `undefined`) when the caller has no cadence to report; the
+ * reader then falls back to its own `maxAgeMs` default.
+ */
+export declare function writeAppHeartbeat(repoDir: string, now?: number, pid?: number, ttlMs?: number): Promise<void>;
+/**
+ * Remove the heartbeat marker (project close / app quit). Best-effort: an
+ * already-missing or unreadable file is not an error.
+ */
+export declare function removeAppHeartbeat(repoDir: string): Promise<void>;
+/**
+ * Read + parse the heartbeat marker. Returns `null` when absent, unreadable,
+ * or corrupt (never throws — a damaged heartbeat is just "no signal").
+ */
+export declare function readAppHeartbeat(repoDir: string): Promise<AppHeartbeat | null>;
+/**
+ * True when a FRESH heartbeat exists for this repo — i.e. the gutterpress app
+ * appears to have this project open right now. Absent/stale/corrupt all read
+ * as "not open" (fail open: `repair` should not block on ambiguous signal).
+ *
+ * Freshness window: the heartbeat's own stamped `ttlMs` (derived from the
+ * writer's actual refresh cadence — see {@link heartbeatTtlMs}) wins when
+ * present; `maxAgeMs` is only a fallback for a heartbeat with none.
+ */
+export declare function isAppHeartbeatFresh(repoDir: string, now?: number, maxAgeMs?: number): Promise<boolean>;

package/dist/lib/asset-inline.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Asset inlining — turns a project's stylesheets into a self-contained
+ * `<style>` block and computes the image copy plan.
+ *
+ * A `styles:` entry is a path to READ, not a file to ship: its text (plus any
+ * local `@import` closure) is inlined, so a stylesheet's location is irrelevant
+ * to the output and themes/shared design systems need no copying. Fonts become
+ * `data:` URIs — which is what guarantees the byte-identical face reaches
+ * Chromium, and therefore the PDF. Small images inline; large ones are copied.
+ *
+ * A missing stylesheet or font is a build error here, at read time, rather than
+ * a 404 during pagination that Paged.js parsed as CSS or silently replaced with
+ * a system face.
+ *
+ * Bundle-safe (CLAUDE.md §1/§3): postcss only.
+ */
+/** Inline images up to this size; copy larger ones (full-bleed page art). */
+export declare const IMAGE_INLINE_MAX_BYTES: number;
+/** One file the build must copy into the output directory. */
+export interface AssetCopy {
+    /** Absolute path of the source file. */
+    from: string;
+    /** Output-relative destination (POSIX separators), e.g. `images/cover.png`. */
+    to: string;
+}
+export interface InlineStylesResult {
+    /** Combined, fully-inlined CSS ready to drop into a `<style>` element. */
+    css: string;
+    /** Files the build must copy into `outDir` (content-addressed CSS images). */
+    copies: AssetCopy[];
+    /** Non-fatal notices (e.g. a remote `url()` left untouched). */
+    warnings: string[];
+}
+/**
+ * Decode percent-escapes so `my%20photo.png` resolves to `my photo.png`.
+ * Falls back to the raw string for a literal `%` in a filename.
+ */
+export declare function decodeRef(ref: string): string;
+/**
+ * Inline the active stylesheets into one CSS string, IN ORDER — the manifest's
+ * `styles:` list is the cascade order (theme first, override second).
+ */
+export declare function inlineStyles(projectDir: string, stylePaths: string[]): Promise<InlineStylesResult>;
+/**
+ * Every file the active stylesheets READ: the stylesheets themselves, their
+ * local `@import` closure, and every local `url()` target (fonts, images).
+ * Absolute paths, deduped, in no particular order.
+ *
+ * This is {@link inlineStyles}'s traversal with the work removed — it resolves
+ * the same references but never reads an asset's bytes, base64-encodes a font,
+ * or plans a copy, so it is cheap enough to re-run whenever the manifest might
+ * have changed. It is deliberately TOTAL: an unreadable stylesheet, an
+ * unparseable one, and a `url()` pointing at a file that does not exist are all
+ * skipped silently. The build reports those properly (as errors, with
+ * locations); a watcher must not throw or it stops watching everything.
+ *
+ * Used by the preview watcher to follow a book's dependencies out of its own
+ * folder — a shared theme's `url("../../fonts/Publisher.woff2")` is a file an
+ * external design tool can replace WITHOUT touching any CSS, and until it is
+ * watched, that edit leaves the "authoritative" preview stale with nothing to
+ * correct it.
+ */
+export declare function collectStyleDependencies(projectDir: string, stylePaths: string[]): Promise<string[]>;
+/**
+ * Turn the renderer's recorded image references into a copy plan. Images keep
+ * their authored relative path, so the author's folder layout is what ships.
+ * A `../` reference is rejected rather than silently relocated — it has no
+ * representable path under the output root.
+ */
+export declare function planImageCopies(projectDir: string, refs: Iterable<string>): Promise<{
+    copies: AssetCopy[];
+    errors: string[];
+}>;

package/dist/lib/browser-pool.d.ts

@@ -0,0 +1,17 @@
+import type { Browser } from "puppeteer-core";
+/**
+ * Start the Chromium launch in the background without awaiting it, so the cold
+ * start overlaps with other build work. Safe to call repeatedly; only the first
+ * call launches. If the launch fails, the pool resets so a later call retries.
+ */
+export declare function prewarmBrowser(timeoutMs: number): void;
+/**
+ * Get the shared browser, launching (and pre-warming) on first use. Reused
+ * across renders in the same process.
+ */
+export declare function getBrowser(timeoutMs: number): Promise<Browser>;
+/**
+ * Close the shared browser. A one-shot CLI build calls this when done so the
+ * process can exit; a preview/watch server calls it on shutdown.
+ */
+export declare function closeBrowser(): Promise<void>;

package/dist/lib/build-error.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The CLI's exit-code contract (UX finding M47) — ONE place the numbers are
+ * defined. Every command's process exit code means the same thing across
+ * `build`/`preview`/`lint`/`validate`/`preflight`/`audit`/`repair`/`publish`/
+ * `new`, so CI can branch on it without parsing output:
+ *
+ *   0  OK        — clean run, nothing to fix.
+ *   1  FINDINGS  — the command completed but reported findings/validation
+ *                  failures (validate/preflight/audit findings, a build's
+ *                  quality-gate rejection). The invocation itself was fine;
+ *                  the content wasn't. Standalone `gutterpress lint` uses this
+ *                  code for CSS lint failures too, but the `build` pipeline's
+ *                  own CSS-lint gate is a documented historical exception
+ *                  that exits 2 instead (see build-runner.ts's
+ *                  runQualityGates) — not a bug, just an inconsistency kept
+ *                  for back-compat.
+ *   2  USAGE     — the invocation itself was wrong: a bad flag, positional,
+ *                  preset, or value. See {@link UsageError} in ./cli-args.ts.
+ *   3  PIPELINE  — the build/render/export pipeline failed for a reason
+ *                  unrelated to CLI usage or findings (I/O error, missing
+ *                  tool, renderer crash, timeout). See {@link BuildError}.
+ *
+ * Commands and error classes import from here instead of hardcoding exit-code
+ * literals; `build-runner.ts` still passes an explicit code per gate (e.g.
+ * pre/post-build validation failures use `EXIT_CODES.FINDINGS`) where a
+ * specific stage needs a code other than this class's default.
+ */
+export declare const EXIT_CODES: {
+    readonly OK: 0;
+    readonly FINDINGS: 1;
+    readonly USAGE: 2;
+    readonly PIPELINE: 3;
+};
+export type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];
+/**
+ * BuildError — the canonical error type for build/pipeline failures.
+ *
+ * Deliberately dependency-free and in its own module: consumers that only need
+ * the error type (e.g. `utils/file-utils.ts`, used by the preview server) must
+ * NOT drag in `build-runner.ts`'s whole pipeline graph (markdown rendering,
+ * ghostscript, paged.js, the browser pool) just to reference an Error class.
+ * `build-runner.ts` re-exports this so existing `import { BuildError } from
+ * "./build-runner"` call sites keep working.
+ *
+ * Defaults to `EXIT_CODES.PIPELINE` (3) — distinct from `UsageError`'s
+ * `EXIT_CODES.USAGE` (2) default, per the contract above. Call sites that need
+ * a different code (findings-style gate failures) still pass one explicitly.
+ */
+export declare class BuildError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode?: number, options?: ErrorOptions);
+}

package/dist/lib/build-fingerprint.d.ts

@@ -0,0 +1,15 @@
+type PdfxFingerprintConfig = {
+    requestedFlavor: "x1a" | "x3" | null;
+    resolvedFlavor: "x1a" | "x3";
+    iccPath: string | null;
+    stripAnnotations: boolean | null;
+};
+export type BuildFingerprintInput = {
+    command: "build";
+    outputDir: string;
+    sourceDir?: string;
+    args: Record<string, unknown>;
+    pdfx: PdfxFingerprintConfig;
+};
+export declare function writeBuildFingerprint(input: BuildFingerprintInput): Promise<string>;
+export {};

package/dist/lib/build-preflight.d.ts

@@ -0,0 +1,43 @@
+import type { BuildFormat } from "./build-runner";
+import type { PdfRenderer } from "./pagination";
+/**
+ * Probe for every tool this build will actually spawn, BEFORE the pipeline
+ * starts running for real. Fails fast with one error that lists every
+ * missing tool plus per-platform install commands.
+ *
+ * Without this, the user waits for lint + render (30-90s) before hitting
+ * `spawn gs ENOENT` from deep inside the post-processing. 50ms preflight
+ * makes the failure actionable and immediate.
+ *
+ * Chromium is REQUIRED for any non-html format and surfaces the same
+ * install-instructions error from requireChromiumExecutable() if missing.
+ * Ghostscript is REQUIRED for pdfx (CMYK conversion) only — plain pdf's
+ * /Creator metadata is stamped via pdf-lib in-process (see ghostscript.ts's
+ * stampCreator) and needs no system tool at all.
+ * qpdf is REQUIRED for pdfx + stripAnnotations (default true).
+ */
+export declare function preflightBuildTools(format: BuildFormat, opts: {
+    stripAnnotations?: boolean;
+    pdfRenderer?: PdfRenderer;
+}, config: {
+    pdfx: {
+        stripAnnotations: boolean;
+    };
+}): Promise<void>;
+export interface Gates {
+    lint: boolean;
+    preValidate: boolean;
+    postValidate: boolean;
+}
+export declare function computeGates(format: BuildFormat, opts: {
+    skipLint?: boolean;
+    skipPreValidate?: boolean;
+    skipPostValidate?: boolean;
+}, config: {
+    lint: {
+        enabled: boolean;
+    };
+    validate: {
+        enabled: boolean;
+    };
+}): Gates;