@animus-ui/extract 0.1.9 → 0.1.11

package/dist/session/extraction-session.d.ts

@@ -0,0 +1,446 @@
+import type { AnimusCoreOptions, ExternalPackageOutcome } from '../pipeline/index';
+/** Options the artifact-publishing session consumes — exactly the shared
+ *  driver core (shared-driver-config). Driver-specific surfaces
+ *  (AnimusNextOptions and the CLI's flag layer) are structurally
+ *  assignable; the session reads only core keys. */
+export type SessionOptions = AnimusCoreOptions;
+import type { SourceEntryOwnership } from '../pipeline/index';
+/**
+ * Module id the Rust emitter injects for the extracted stylesheet — also the
+ * exact resolve.alias key with-animus registers for it, which the adapter's
+ * alias harvesting must skip.
+ */
+export declare const ANIMUS_CSS_MODULE_ID = ".animus/styles.css";
+/** Watch-cycle change sets, as reported by the bundler's watcher. */
+export interface WatchChanges {
+    modifiedFiles?: ReadonlySet<string>;
+    removedFiles?: ReadonlySet<string>;
+}
+/**
+ * Bundler-agnostic extraction pipeline: system loading, source discovery
+ * and ingestion, external-package collection, analysis, stylesheet and
+ * system-props emission, and watch-cycle diffing.
+ *
+ * The webpack adapter (plugin.ts) owns only bundler wiring: hook
+ * registration, alias harvesting from the compiler config, in-memory asset
+ * replacement, and translating watch events into `handleWatchUpdate`
+ * change sets. Keeping this class free of webpack types is deliberate — a
+ * future Turbopack integration must drive the same session from outside
+ * the bundler (Turbopack has no compiler-hook surface), reusing everything
+ * here unchanged.
+ *
+ * Outputs are published through the package singleton (shared CSS,
+ * manifest, system props) and written to `.animus/` on disk.
+ */
+export declare class ExtractionSession {
+    /** Set by the adapter before any pipeline run. */
+    rootDir: string | null;
+    /** Serialized path aliases, harvested by the adapter from bundler config. */
+    pathAliasesJson: string | null;
+    private assetCopyCache;
+    /** Physical asset files registered with the host watcher. */
+    assetDependencyPaths: Set<string>;
+    private assetDependencyKeys;
+    /** Emitter identity override for the system-props module id. Webpack mode
+     *  (null) injects the absolute `.animus/system-props.js` path, resolved by
+     *  NormalModuleReplacement; Turbopack rejects absolute-path imports, so
+     *  its driver sets the virtual id that `resolveAlias` maps to disk. */
+    systemPropsModuleId: string | null;
+    /** Whether the analysis-inputs hydration corpus is serialized + written.
+     *  False (webpack mode): the loader shares the pipeline process and reads
+     *  the manifest from memory — the corpus is never persisted. True is set
+     *  by the Turbopack orchestration driver, whose isolated loader workers
+     *  replay it (spec: next-turbopack-integration, "Manifest disk artifact" /
+     *  "Webpack mode skips the hydration corpus"). */
+    persistAnalysisInputs: boolean;
+    /** Absolute directory prefixes for external DS packages (loader allowlisting). */
+    externalPackageDirs: string[];
+    /** Absolute package dir → owning specifier (cross-source correlation). */
+    private externalDirOwners;
+    /** rootDir-relative external file → owning specifier (correlation join). */
+    private externalFileOwners;
+    /** External package specifier → absolute source entry path. */
+    externalSourceEntries: Map<string, string>;
+    /** SourceId derivation authority for the current generation (openspec:
+     *  external-source-watch-ingestion, design D2) — canonical roots
+     *  realpath'd once per full pipeline; alias→SourceId associations
+     *  recorded while files exist so deletion resolves through the cache. */
+    private sourceIdentity;
+    /** Canonical admitted external root → declared specifiers (set-valued
+     *  ownership, design D2; duplicate specifiers resolving to one canonical
+     *  root share it). Engine watch wiring and tests read this. */
+    externalRootOwners: Map<string, Set<string>>;
+    /** Canonical external root → the extension set its collection walk used
+     *  (widened for dist-only roots); rewalks and classification share it. */
+    private externalRootExtensions;
+    /** Canonical admitted external watch roots — the engine-side watch
+     *  surface (webpack contextDependencies / Turbopack watchers). */
+    externalWatchRoots: string[];
+    /** Canonical external root → (raw sourceKey → {raw content hash, recorded
+     *  abs spelling}): the previous-generation inventory a dirty-root rewalk
+     *  diffs against (design D3). Raw hashes — MDX preprocessing never skews
+     *  the diff; the recorded abs path is a registered deletion alias, so a
+     *  reconstructed deletion always resolves through cached identity. */
+    private externalInventory;
+    /** Sticky diagnostics (design D5/D7): stable key → message, re-surfaced
+     *  on every full pipeline until the underlying condition clears. */
+    readonly stickyDiagnostics: Map<string, string>;
+    /** Volume-membership predicate for the cross-volume gate (design D5).
+     *  Injected seam: the shared predicate only discriminates on Windows
+     *  (win32 semantics are unit-tested via path.win32), so runtime tests
+     *  drive the gate through this. */
+    sharesProjectVolume: (projectRoot: string, externalRoot: string) => boolean;
+    /** Orchestrator seams (openspec: external-source-watch-ingestion, design
+     *  D4). `onExternalRootResolved` fires per volume-admitted external root
+     *  DURING collection — after resolution, BEFORE that root's sources are
+     *  walked — so a watching host can open its handle with no blind gap
+     *  between scan and watch. `onExternalRootsCommitted` fires once after a
+     *  successful full-pipeline publication with the complete admitted
+     *  canonical root set (the host's promote/replay/close-old phase; a
+     *  failed pipeline never fires it, so the host rolls back). */
+    onExternalRootResolved: ((canonicalRoot: string) => void) | null;
+    onExternalRootsCommitted: ((canonicalRoots: string[]) => void) | null;
+    private readonly options;
+    private readonly staticCssJson;
+    private system;
+    /** Discovery-time keyframes diagnostics awaiting the shared surfacing pass. */
+    private externalKeyframesDiagnostics;
+    /** Full package-resolution map from the last full pipeline — replayed by
+     *  incremental passes (sourceEntries alone omits dist-resolved packages). */
+    private lastPackageMap;
+    private fileCache;
+    analysisEntryCache: Map<string, {
+        hash: string;
+        source: string;
+    }>;
+    sourceOwnership: Record<string, SourceEntryOwnership>;
+    private systemDependencyKeys;
+    /** Loader-reported dependency paths for bundler watch registration. */
+    systemDependencyPaths: string[];
+    private systemDependencyHashes;
+    private lastSystemPropsHash;
+    /** Per-payload write guards: payloadHash gates rewrites (byte-identical
+     *  payloads leave disk untouched); diskHash is the hash of the CURRENT
+     *  disk bytes (envelope included) recorded in the analysis-commit. null =
+     *  not yet seeded (first publication reads the artifact's envelope so a
+     *  same-session restart never rewrites byte-identical artifacts). */
+    private artifactRecords;
+    /** Last written analysis-commit; null = seeded from disk on first use. */
+    private lastCommit;
+    /** Session identity — claimed once per PROCESS (one Next invocation),
+     *  adopted by every subsequent session instance so all compilers share
+     *  one artifact tree (design D2: `next dev`/`next build` co-writing are
+     *  separate processes and therefore separate sessions). */
+    readonly sessionId: string;
+    /** Epoch value of the last published analysis; null = not yet known
+     *  (seeded from the session dir's artifact on first publication so a
+     *  same-session restart with unchanged plans never rewrites bytes). */
+    private lastEpochValue;
+    /** Watcher debounce ceiling feeding status deadlines (design D3). */
+    debounceCeilingMs: number;
+    /** Test seam: observes every session-artifact write (name, content)
+     *  post-rename — write ORDER is part of the transaction contract. */
+    onArtifactWrite: ((name: string, content: string) => void) | null;
+    /** Status attempt bookkeeping (design D3). */
+    private statusAttemptId;
+    private statusAttemptOpen;
+    /** Monotonic first-emission witness (openspec: standalone-extraction-cli,
+     *  watch readiness): flips true once the first complete publication
+     *  succeeds and never regresses — every later status write (idle AND
+     *  failed) carries it, so readiness stays observable across attempts. */
+    private firstEmissionComplete;
+    /** Debounce-window observations pending analysis (sourceKey → hash). */
+    private debouncePending;
+    /** Session-start hygiene (pruning + legacy cleanup) runs once. */
+    private sessionStartHygieneDone;
+    private lcssTargets;
+    constructor(options: SessionOptions);
+    /** This session's artifact directory. Requires `rootDir` to be set. */
+    get sessionDir(): string;
+    get verbose(): boolean;
+    private log;
+    private warn;
+    private now;
+    private elapsed;
+    /** Lazily-computed scan config (options are constructor-fixed, so the
+     *  derivation is stable for the session's lifetime). */
+    /** Diagnostic prefix label — drivers set their own so a host's errors
+     *  never masquerade as another driver's (inc 05 review S1). The default
+     *  keeps the Next plugin's historical prefix. */
+    driverLabel: string;
+    /** Per-specifier discovery outcomes from the last full collection —
+     *  driver-consumed reporting surface (the CLI's summary). */
+    lastExternalOutcomes: ExternalPackageOutcome[];
+    /** Component count of the last published analysis, or null before the
+     *  first — the CLI's publish path reads this instead of re-parsing the
+     *  manifest JSON every cycle. */
+    lastComponentCount: number | null;
+    /** Driver-owned STRUCTURAL exclusions (a CLI outDir inside the root),
+     *  joined to the never-replaceable set — never the user `exclude` list,
+     *  whose presence would flip the replace semantics and silently drop the
+     *  replaceable defaults. Set before the first pipeline run (the scan
+     *  config is memoized). */
+    structuralExclude: string[];
+    private scanConfigMemo;
+    /** Per-pattern exclusion hit counts from this session's matcher —
+     *  driver-consumed reporting surface (dead-pattern visibility). */
+    getExcludeStats(): ReadonlyMap<string, number>;
+    /** Resolve the scan configuration from options — the single source of the
+     *  exclude/extension policy shared by the full and incremental pipelines. */
+    private resolveScanConfig;
+    /**
+     * Watch entry point: one single-flight analysis transaction per event
+     * batch (openspec: next-webpack-served-transform-coherence, design D3).
+     * The first entering session runs the transaction; every concurrent
+     * entry — same session re-entered, or another compiler's session
+     * (client/server/RSC each hold their own instance) — joins the in-flight
+     * promise, so no compiler proceeds against a generation older than the
+     * one the transaction publishes. A rejected transaction rejects every
+     * joiner; the gate always clears.
+     */
+    handleWatchUpdate(changes: WatchChanges): Promise<void>;
+    /**
+     * Owner-side entry for a batch observed by a NON-OWNING compiler's
+     * watcher. Serializes behind any in-flight transaction, then runs the
+     * forwarded batch as its own transaction — never drops it (a forwarded
+     * batch has no other delivery; content-hash diffing makes an
+     * already-covered batch a cheap no-op).
+     */
+    ingestForwardedBatch(changes: WatchChanges): Promise<void>;
+    /**
+     * Incremental watch pass: geological reset when the system file changed,
+     * otherwise content-hash diffing restricted to the watcher's change sets
+     * (falling back to a full discovery walk when no sets are provided).
+     */
+    private processWatchUpdate;
+    /** The shared ingestion policy point (vite-plugin parity BY CODE): the
+     *  capability guard, facts memo, and warn-dedupe lifecycle live in the
+     *  pipeline; this host holds only its prefix, strict flag, and warn sink. */
+    private sourceIngestor;
+    /** Prepare one raw-source corpus through the shared adaptation boundary. */
+    private ingestRawSources;
+    /** Ingest and apply the shared per-file quarantine: one invalid original
+     *  (an `.mdx` with the optional peer absent, an unsupported `.svelte`
+     *  shape) warns and drops; the rest of the corpus still analyzes. Strict
+     *  mode throws from the shared policy — callers route that into their own
+     *  status/rollback handling. */
+    private ingestAccepted;
+    /** Surface parser diagnostics under the shared strict/warn policy. */
+    private surfaceSourceDiagnostics;
+    /**
+     * Correlate diagnostics emitted against generated children back to the
+     * external package owning their raw original.
+     */
+    private projectExternalFileOwners;
+    /** Publish the raw cache and complete parser projection atomically. */
+    private publishSourceIngestion;
+    runFullPipeline(pending?: Array<[string, string]>): Promise<void>;
+    /** The per-generation source state runFullPipeline mutates, captured as
+     *  ONE object so the restore below cannot omit a member. The three
+     *  deep-copied fields are the ones later steps mutate in place rather
+     *  than reassign; everything else is rebound wholesale on success. */
+    private snapshotSourceState;
+    private restoreSourceState;
+    /**
+     * Reset analysis state for HMR geological reset. Payload write guards go
+     * back to null so the next publication reseeds them from the disk
+     * envelopes — a byte-identical post-reset artifact is still not
+     * rewritten.
+     */
+    resetForHmr(): void;
+    /**
+     * The (sourceKey, observedSourceHash) pairs of a watch batch — cheap
+     * evidence for the status file's pending set on the geological-reset
+     * path, where the batch's component edits ride along with the system
+     * edit (design D3: loaders wait only on observed inputs).
+     */
+    private pendingFromBatch;
+    /**
+     * Root-dirty inventory reconciliation (design D3): partition the
+     * watcher's change sets into explicit FILE events and external ROOT hits
+     * (a reported path that IS an admitted root, or a directory inside one),
+     * rewalk each dirty root through the shared discovery policy, diff the
+     * SourceId+raw-hash inventory against the previous generation, and merge
+     * the reconstructed created/edited/deleted deltas with the explicit
+     * events (identity-level dedup happens downstream at the cache gate).
+     * Deletion falls out of the inventory diff — webpack may report only the
+     * directory (probe-proven).
+     */
+    private reconcileExternalRoots;
+    /**
+     * Route one watcher-reported path (design D1/D2): a project-root member
+     * (lexical containment — existing local semantics preserved; consumer
+     * exclude patterns apply) or an admitted external member (identity
+     * resolution with symlink-escape rejection; package-relative excludes
+     * mirror the collection walk's filters — guardrail G1, one policy).
+     * Returns null for dropped paths.
+     */
+    private classifyWatchPath;
+    /** Build full raw originals for one shared adaptation attempt. */
+    private buildRawEntriesFromCache;
+    /**
+     * Run incremental pipeline with cache-aware file entries.
+     * Reuses system config from the last full pipeline run.
+     */
+    private runIncrementalPipeline;
+    /**
+     * Shared analysis + emit core for both pipelines — the single call site
+     * that routes every manifest through the shared `runProjectAnalysis`,
+     * reachable from both runFullPipeline (production) and
+     * runIncrementalPipeline (HMR).
+     *
+     * Owns diagnostic surfacing, CSS assembly + styles.css write guard,
+     * system-props module emit, and the timing log. The engine's own
+     * `dev_mode` (reconciliation pruning) is derived separately via
+     * `engineDevMode` — an explicit `mode` option overrides the pipeline
+     * path there. For everything else the `devMode` flag is the ONLY
+     * behavioral fork:
+     *
+     * - `false` (production): computes bt.analysis + logs the extraction
+     *   report, and writes system-props.js UNCONDITIONALLY (no
+     *   lastSystemPropsHash guard).
+     * - `true` (HMR): skips the report log, and guards the system-props.js
+     *   write by lastSystemPropsHash.
+     *
+     * The disk artifacts land under the session directory in transaction
+     * order (design D1): manifest → analysis-inputs (Turbopack orchestration
+     * only) → styles.css → system-props → analysis-commit →
+     * replacements-epoch (last, only when moved). The analysis-status file walks starting → analyzing →
+     * committing → idle around the attempt, landing in `failed` (with the
+     * diagnostic) on any throw (design D3).
+     */
+    private analyzeAndEmit;
+    /**
+     * The engine's `dev_mode` flag (retain all components vs reconciliation
+     * pruning) is an EMISSION decision, so an explicit `mode` option wins over
+     * the pipeline path (core-options: `mode` "decides emitted bytes …
+     * engine devMode"). Without an explicit mode the historical per-pipeline
+     * default applies: full = production pruning, incremental = dev retention.
+     * A pinned-production watch must not flip to unpruned CSS on its first
+     * incremental republication, and a pinned-development full build must
+     * retain all components.
+     */
+    private engineDevMode;
+    private analyzeAndEmitAttempt;
+    /** Open a status attempt (attemptId increments once per burst — a
+     *  debouncing pre-write and the analysis that follows share one id). */
+    private beginStatusAttempt;
+    /** Write the session's analysis-status artifact (design D3). Terminal
+     *  states (idle/failed) close the attempt. */
+    private writeAnalysisStatus;
+    /**
+     * Orchestrator seam (Turbopack watcher): record watch events observed
+     * during the debounce window so a loader running ahead of the analysis
+     * has positive evidence to wait on (design D3 'debouncing'). Paths are
+     * filtered by the scan config and hashed at observation time.
+     */
+    noteDebouncedWatchEvents(absPaths: Iterable<string>): void;
+    /** One pending microtask flushes a burst of debounce observations. */
+    private debounceStatusWriteScheduled;
+    /**
+     * Write one payload artifact into the session directory, enveloped with
+     * `{sessionId, generation, replacementEpoch, payloadHash}` and rewritten
+     * only when the PAYLOAD bytes changed (byte-identical re-analyses leave
+     * disk untouched — spec: "Unchanged manifest is not rewritten"). The
+     * recorded diskHash (hash of the enveloped bytes) feeds the
+     * analysis-commit.
+     */
+    private publishPayloadArtifact;
+    /** Reconstruct a payload write guard from the on-disk artifact's envelope
+     *  (same-session restart: a byte-identical payload must not rewrite). */
+    private seedPayloadRecord;
+    /** Last analysis-commit persisted in this session's directory, or null. */
+    private seedCommitFromDisk;
+    /**
+     * Publish the analysis-commit — the transaction identity (design D1).
+     * Written AFTER every payload and BEFORE the epoch; skipped entirely when
+     * the payload set (disk hashes) and epoch are unchanged, so a no-op
+     * re-analysis neither re-keys loader-worker hydration nor burns a
+     * generation.
+     */
+    private publishAnalysisCommit;
+    /**
+     * Publish the canonical replacement epoch: maintain the session-scoped
+     * disk witness `{schema, sessionId, epoch}`, rewritten ONLY when the
+     * epoch VALUE changes so style-only analyses and same-session restarts
+     * leave bytes and mtime untouched, then expose the value through the
+     * singleton for the plugin's needBuild fan-out and the loader's catch-up
+     * re-check. Every VALUE move also reconciles sibling sessions' epoch
+     * artifacts (below) — the webpack cold-cache validity witness.
+     */
+    private publishReplacementEpoch;
+    /**
+     * Sibling epoch reconciliation — the cross-session half of the webpack
+     * persistent-cache witness (spec: dev-served-transform-coherence,
+     * "Offline change invalidates restored modules"). Restored-module
+     * snapshots reference the epoch artifact of the session that BUILT them;
+     * with session-scoped trees that file would otherwise sit untouched
+     * forever, keeping stale snapshots valid. Whenever this session's epoch
+     * value moves, delete every sibling epoch artifact that disagrees (their
+     * snapshots must invalidate — restore-on-demand then rebuilds from the
+     * current generation) and leave agreeing siblings byte-untouched (warm
+     * restores stay valid). Deleting a stale artifact is pruning, not a
+     * foreign-session write; races with concurrent sessions are tolerated
+     * (S14).
+     */
+    /** Sibling ids already reconciled away (artifact deleted or absent) —
+     *  nothing left to invalidate for them on later moves. */
+    private reconciledSiblingIds;
+    /** sessions-root listing memo, keyed by the root dir's mtime — a new or
+     *  pruned sibling DIRECTORY moves it; agreeing siblings stay listed. */
+    private siblingListing;
+    private reconcileSiblingEpochs;
+    /** Epoch value held by this session's on-disk artifact, or null when
+     *  absent, unreadable, or not the expected schema. */
+    private diskEpochValue;
+    /** True when the flat `.animus/` advisory lock names a live pid — a CLI
+     *  invocation (build mid-publish, or a whole watch run) owns the flat
+     *  tree right now, and any instantaneous inconsistency is its in-flight
+     *  write, not debris. */
+    private cliWriterHoldsLock;
+    /** Session-start hygiene (design D2): delete legacy flat artifacts
+     *  (unreachable by session-scoped loaders; the standalone CLI is the one
+     *  remaining writer of flat payload names, and its live output is
+     *  fenced off below) and prune sibling session directories older than
+     *  the retention window — never the own dir, tolerating races with
+     *  concurrently-pruning sessions (S14). */
+    private runSessionStartHygiene;
+    /** Ensure the session directory exists and write one artifact into it.
+     *  Write-then-rename so cross-process readers (Turbopack loader workers)
+     *  can never observe a torn half-written file. The tmp name carries the
+     *  pid — Next dev evaluates the config in more than one process, and two
+     *  sessions writing the same artifact must not race on one tmp path. */
+    private writeSessionArtifact;
+    /**
+     * asset() placeholder substitution (global-styles-system): resolve each
+     * referenced specifier through Node resolution, copy the bytes into the
+     * session directory's `assets/` under a content-hashed name, and
+     * substitute a RELATIVE url — relative to the session-scoped styles.css,
+     * which sits beside `assets/`, so the emitted `./assets/<file>` form is
+     * unchanged. The stylesheet is processed by Next's own CSS pipeline
+     * (webpack and Turbopack alike), which applies its native asset handling
+     * — publicPath and output hashing — to relative url() references.
+     * Unsubstitutable specifiers warn and emit literally in non-strict mode,
+     * fail the build under `strict: true`.
+     */
+    private substituteAssetReferences;
+    private trackAssetDependency;
+    /**
+     * Resolve an asset specifier to an absolute file via the shared pipeline
+     * resolver (host aliases → Node resolution → package root), with one
+     * session-local last resort: an already-discovered source entry's package
+     * root (dist-less workspace kits the shared resolver cannot see).
+     */
+    private resolveAssetSpecifier;
+}
+/**
+ * Sync `.animus/assets/` to the current build's content-hashed file set:
+ * anything else in the directory is a superseded revision (the copies are
+ * content-addressed and never overwritten) or the leftover of an asset()
+ * reference that no longer exists. Failures are tolerated per entry — Next
+ * dev evaluates the config in more than one process, and a concurrent
+ * session may have removed (or be about to rewrite) the same file; every
+ * pass rewrites whatever of its own set is missing, so races self-heal.
+ */
+export declare function pruneStaleAssets(assetsDir: string, expected: ReadonlySet<string>): void;
+//# sourceMappingURL=extraction-session.d.ts.map

package/dist/session/extraction-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-session.d.ts","sourceRoot":"","sources":["../../session/extraction-session.ts"],"names":[],"mappings":"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"}

package/dist/session/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `@animus-ui/extract/session` — the artifact-publishing extraction
+ * session and its watcher orchestration, factored out of the Next plugin
+ * (openspec: standalone-extraction-cli, D1). Every driver — the Next
+ * plugin, the standalone CLI, the transform host — is a thin shell over
+ * this one drive loop; none may fork it.
+ *
+ * UNSTABLE SURFACE: this subpath exists for Animus's own drivers; its
+ * exports are the driver-consumed surface only (deliberately narrower than
+ * the session modules — internal state mutators, envelope encoders, and
+ * test seams stay off the published API) and may change without semver
+ * ceremony until the standalone CLI ships its consumer contract
+ * (standalone-extraction-cli inc 03/07).
+ */
+export { ANIMUS_CSS_MODULE_ID, ExtractionSession, pruneStaleAssets, } from './extraction-session';
+export type { SessionOptions, WatchChanges } from './extraction-session';
+export { collectSessionAssets, verifyCommitRecord } from './published-set';
+export type { SessionAsset } from './published-set';
+export { analysisCommitPath, analysisInputsPath, analysisStatusPath, CLI_COMMIT_ARTIFACT, CLI_LOCK_ARTIFACT, MANIFEST_ARTIFACT, manifestPath, readJsonEnvelope, replacementEpochPath, SESSION_ASSETS_DIR, sessionArtifactDir, STYLES_ARTIFACT, stylesPath, SYSTEM_PROPS_ARTIFACT, systemPropsPath, TURBOPACK_SYSTEM_PROPS_ID, } from './session-paths';
+export type { AnalysisCommit, AnalysisStatus, SessionEnvelope, } from './session-paths';
+export { runSessionPipeline, startTurbopackWatcher, } from './turbopack-orchestrator';
+export type { TurbopackWatcherHandle } from './turbopack-orchestrator';
+export { claimExclusiveSessionOwner, engineApi, getAnalysisPromise, getAnalyzedHashes, getManifestJson, getReplacementEpoch, getSessionArtifactDir, getSharedCss, getSharedExternalDirs, getSharedExternalEntries, getSharedSystemProps, setAnalysisPromise, setSharedEngine, } from './singleton';
+//# sourceMappingURL=index.d.ts.map

package/dist/session/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../session/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,qBAAqB,EACrB,eAAe,EACf,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,cAAc,EACd,cAAc,EACd,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EACL,0BAA0B,EAC1B,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,qBAAqB,EACrB,YAAY,EACZ,qBAAqB,EACrB,wBAAwB,EACxB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,GAChB,MAAM,aAAa,CAAC"}

package/dist/session/published-set.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The CLI published-set contract, shared logic (openspec:
+ * standalone-extraction-cli D3): ONE implementation of "does this flat
+ * artifact set verify against its commit record" and ONE collector for the
+ * session's copied asset() files — consumed by the CLI writer
+ * (staging/verification) and the session's start hygiene (confinement
+ * gate). Two copies of either had already drifted once: the hygiene copy
+ * verified payloads as UTF-8 strings while the writer hashed raw bytes, so
+ * any asset-carrying set (fonts are not UTF-8) could never verify and a
+ * legitimately published set was classified as debris.
+ */
+/**
+ * Recompute every payload hash recorded in the directory's commit record
+ * and compare — raw bytes on both sides, matching the writer's hashing
+ * domain. Returns failure lines; empty means the set verifies. An absent
+ * or unparsable record is itself a failure (the record is written LAST, so
+ * a torn or aborted publish cannot verify).
+ */
+export declare function verifyCommitRecord(dir: string): string[];
+/** One published asset file: its session-relative name and raw bytes. */
+export interface SessionAsset {
+    name: string;
+    bytes: Buffer;
+}
+/**
+ * Snapshot the session's copied asset() files (sorted by name) — read
+ * BEFORE the session tree is disposed. The emitted stylesheet references
+ * them as `./assets/<name>`, so every driver must publish them beside its
+ * stylesheet or the urls dangle.
+ */
+export declare function collectSessionAssets(sessionDir: string | null): SessionAsset[];
+//# sourceMappingURL=published-set.d.ts.map

package/dist/session/published-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"published-set.d.ts","sourceRoot":"","sources":["../../session/published-set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CA6BxD;AAED,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,GAAG,IAAI,GACxB,YAAY,EAAE,CAOhB"}

package/dist/session/resolve-packages.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolve external DS package specifiers to rootDir-relative entry paths.
+ * Node-generic (no webpack APIs): Pass 1 walks the consumer's workspaces for
+ * matching package names; Pass 2 falls back to `require.resolve`. Specifiers
+ * that resolve nowhere are simply omitted (spec: silent skip).
+ */
+export declare function resolvePackagesByName(rootDir: string, names: string[]): Record<string, string>;
+//# sourceMappingURL=resolve-packages.d.ts.map

package/dist/session/resolve-packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-packages.d.ts","sourceRoot":"","sources":["../../session/resolve-packages.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0DxB"}