@t4r71/dsh-dual-axis 0.1.0

package/lib/types/axis-command.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The dual-axis bundle's command registration: the one write path the two
+ * composer dropdowns reach the host through.
+ *
+ * The name is NOT permission. @deepseek-ai/dsh-permission-presets registers
+ * /permission on the global command layer, and the registry's NamedEntries
+ * throws on a duplicate global name, so reusing it would fail this plugin's
+ * load. The preset picker keeps /permission; this command owns the axes.
+ *
+ * Registration rides ctx.inject(['commands'], …) rather than the plugin's
+ * static inject: a profile without a command registry composes this bundle
+ * for its fence and prompt, and an unconditional ctx.commands access would fail
+ * that load.
+ *
+ * The write is a WHOLE-DOCUMENT settings write and therefore asynchronous, so
+ * the handler is too. A lost revision race settles as an ordinary command
+ * error carrying the conflict's own sentence: the dispatching surface renders
+ * it beside the picker, and nothing is reported as applied that was not stored.
+ *
+ * @module @t4r71/dsh-dual-axis/axis-command
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Session } from '@deepseek-ai/dsh-session';
+import type { EffectiveScopes } from './axis.ts';
+/** The registered command name, without its leading slash. */
+export declare const AXIS_COMMAND_NAME = "axis";
+/** What the registration needs from its owner. */
+export interface AxisCommandOptions {
+    /**
+     * The session's standing axis pair, read from the session axis store — the one
+     * source every other consumer reads. Supplies the axis a one-axis entry does
+     * not name.
+     * @param session - the session the invocation belongs to.
+     * @returns the pair in force, with both defaults filled in.
+     */
+    readonly current: (session: Session) => EffectiveScopes;
+    /**
+     * The rule-group ids the settings page currently defines. Read at the moment
+     * of the invocation so a group created since startup is selectable, and used
+     * only to REFUSE an unknown id: an existing id is recorded verbatim and
+     * expanded at the moment of use, never here.
+     * @returns the defined ids.
+     */
+    readonly knownGroups: () => ReadonlySet<string>;
+    /**
+     * Store one session's new pair. Supplied by the composing plugin, which owns
+     * the store; the command layer never reaches the settings document itself.
+     * @param session - the session to write.
+     * @param axes - the complete new pair.
+     */
+    readonly write: (session: Session, axes: EffectiveScopes) => Promise<void>;
+}
+/**
+ * Register the axis command for every composed command adapter.
+ * @param ctx - host context; the registration is owned by this context's fiber.
+ * @param options - the standing-pair reader, the group-id reader, and the write path.
+ */
+export declare function registerAxisCommand(ctx: Context, options: AxisCommandOptions): void;
+//# sourceMappingURL=axis-command.d.ts.map

package/lib/types/axis-entry.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The dual-axis command's argument grammar: one client-composed entry string
+ * into one access axis.
+ *
+ * The grammar is owned by the browser half's pickers, which emit exactly two
+ * forms — <axis>:<deny|workspace|all> for the three closed values, and
+ * <axis>:custom:base=<deny|workspace|all>[,groups=<id>|<id>][,allow=<absolute path>][,deny=<absolute path>]
+ * from the path editor, where a repeated key carries several entries.
+ *
+ * A `groups` entry records the IDS ONLY, checked against the ids the settings
+ * page currently defines and then stored verbatim. The group's rules are never
+ * expanded into the entry: expansion happens at the moment of use, so editing a
+ * group reaches every session that references it without a restart.
+ *
+ * The caller supplies the session's standing pair so a one-axis entry returns
+ * the complete new pair; the axis the entry does not name keeps its value.
+ *
+ * @module @t4r71/dsh-dual-axis/axis-entry
+ */
+import type { EffectiveScopes } from './axis.ts';
+/** The two axis names an entry string may start with. */
+export declare const AXIS_ENTRY_NAMES: readonly string[];
+/** A parsed entry, or the sentence explaining why it is not one. */
+export type AxisEntryParse = {
+    readonly ok: true;
+    readonly axes: EffectiveScopes;
+} | {
+    readonly ok: false;
+    readonly problem: string;
+};
+/** The separator between rule-group ids in one `groups` entry. */
+export declare const GROUP_ID_SEPARATOR = "|";
+/**
+ * Read one client-composed axis entry into the complete axis pair it selects.
+ * @param rawInput - the command invocation's verbatim input; the commands
+ *   registry passes the text after the command name including the separating
+ *   space, so this trims first.
+ * @param current - the session's standing pair; the axis the entry does not
+ *   name keeps its value from here.
+ * @param knownGroups - the rule-group ids the settings page currently defines;
+ *   a `groups` entry naming anything else is refused.
+ * @returns the new pair, or the sentence explaining why the entry was refused.
+ */
+export declare function parseAxisEntry(rawInput: string, current: EffectiveScopes, knownGroups?: ReadonlySet<string>): AxisEntryParse;
+//# sourceMappingURL=axis-entry.d.ts.map

package/lib/types/axis.d.ts

@@ -0,0 +1,131 @@
+/**
+ * The read/write ACCESS AXES of the file sandbox: the per-axis vocabulary a
+ * session selects and the lossless mapping onto the legacy single `mode`.
+ *
+ * This is the 0.1.7 port of the algebra upstream deleted. 0.1.6 shipped it as
+ * `@deepseek-ai/dsh-sandbox/access` (152 lines) and
+ * `@deepseek-ai/dsh-sandbox/scope` (152 lines); 0.1.7 has neither symbol nor
+ * file, so the package carries its own copy and keeps the 0.1.6 semantics
+ * verbatim: four kinds, `custom` = base + allow - deny with deny winning.
+ *
+ * One axis answers "which absolute paths may this execution touch". `deny`
+ * permits nothing, `workspace` permits the calling session's workspace root
+ * plus the platform temp areas, `all` is the whole host filesystem, and
+ * `custom` names a BASE kind plus absolute path ADDITIONS and REMOVALS —
+ * path lists, not patterns.
+ *
+ * `mode` REMAINS the write axis's persistence spelling. The session-format
+ * whitelist pins its literal values, so this module keeps `mode` derivable
+ * from the write scope in both directions instead of replacing it:
+ * {@link scopeOfMode} and {@link modeOfScope} are the two halves of that
+ * bijection, and `custom` maps onto the mode implied by its own base.
+ *
+ * @module @t4r71/dsh-dual-axis/axis
+ */
+import type { SandboxExecutionPolicy, SandboxMode } from '@deepseek-ai/dsh-sandbox';
+/**
+ * One axis's kind. `deny` touches nothing; `workspace` is the session's
+ * workspace plus the platform temp areas; `all` is the host filesystem;
+ * `custom` carries additions and removals over a `base`.
+ */
+export type AxisScopeKind = 'deny' | 'workspace' | 'all' | 'custom';
+/** The comparison base a `custom` scope adds to and removes from. */
+export type AxisBase = 'deny' | 'workspace' | 'all';
+/**
+ * One axis's complete value. The three closed kinds carry no payload;
+ * `custom` carries the absolute paths its selection adds (`allow`) and the
+ * absolute paths it removes even from the base (`deny`). Removal wins over
+ * addition — see {@link scopeContains}.
+ */
+export type AxisScope = {
+    kind: Exclude<AxisScopeKind, 'custom'>;
+} | {
+    kind: 'custom';
+    /** The scope the additions and removals are applied over. */
+    base: AxisBase;
+    /**
+     * Ids of the rule groups this axis references. The DEFINITION of an id is
+     * read from the settings page at the moment of use, never stored here: a
+     * session that copied a group's contents would keep enforcing the copy after
+     * the group changed, and copies of one group drift apart.
+     */
+    groups?: readonly string[] | undefined;
+    /** Absolute paths added to the base. */
+    allow: readonly string[];
+    /** Absolute paths removed from (base ∪ allow). */
+    deny: readonly string[];
+};
+/** Every {@link AxisScopeKind}, for option advertisement and untrusted-value validation. */
+export declare const AXIS_KINDS: readonly AxisScopeKind[];
+/** Every {@link AxisBase}, for option advertisement and untrusted-value validation. */
+export declare const AXIS_BASES: readonly AxisBase[];
+/** The default READ axis: every mode permitted reading before the axes existed, so the whole host. */
+export declare const DEFAULT_READ_SCOPE: AxisScope;
+/** The default WRITE axis: the session workspace plus the platform temp areas. */
+export declare const DEFAULT_WRITE_SCOPE: AxisScope;
+/**
+ * Whether an untrusted runtime value names one of the three `SandboxMode` members.
+ *
+ * The TYPE says `SandboxMode`; the session LOG says whatever a past writer put
+ * there. A replayed or foreign log can carry a mode this build never wrote, and
+ * a fold that trusts it would take the whole projected axis cell down with it.
+ * This guard is the boundary that turns 'the log claims a mode' into 'the log
+ * claims a mode this build understands': callers read a false answer as 'names
+ * no mode' and keep the axis value they already had.
+ * @param value - the untrusted value from a session-log payload.
+ * @returns true when the value is a `SandboxMode`.
+ */
+export declare function isSandboxMode(value: unknown): value is SandboxMode;
+/**
+ * The write scope a legacy `mode` means.
+ * @param mode - the sandbox mode.
+ * @returns the equivalent write scope.
+ */
+export declare function scopeOfMode(mode: SandboxMode): AxisScope;
+/**
+ * The mode an axis BASE implies — the shared half of {@link modeOfScope}. The
+ * three-value mode set is closed, so every base spells exactly one mode.
+ * @param base - the axis base to spell.
+ * @returns the mode that base has always been persisted as.
+ */
+export declare function modeOfAxisBase(base: AxisBase): SandboxMode;
+/**
+ * The legacy `mode` a write scope is spelled as. `custom` resolves through its
+ * own base: the mode names the containment the fence must not exceed, while the
+ * scope's additions and removals ride beside it.
+ * @param scope - the write axis value.
+ * @returns the mode that spells this scope's base.
+ */
+export declare function modeOfScope(scope: AxisScope): SandboxMode;
+/** The axis pair actually in force, with both defaults filled in. */
+export interface EffectiveScopes {
+    /** The read axis in force. */
+    read: AxisScope;
+    /** The write axis in force. */
+    write: AxisScope;
+}
+/**
+ * Read the axis pair a resolved policy carries, falling back to the defaults.
+ * The policy's `mode` is authoritative for the write axis's BASE: a policy
+ * that carries no write axes writes exactly what its mode always meant, so
+ * every pre-existing policy keeps its exact behavior.
+ *
+ * 0.1.7's `SandboxExecutionPolicy` has no `readScope` / `writeScope`
+ * members (only `mode`, `workspaceRoot`, `sessionId?`), so the axes arrive
+ * through the extra argument this package's own fence passes. The
+ * `mode`-derived fallback keeps the function total for the upstream type.
+ * @param policy - the resolved policy (supplies `mode`).
+ * @param axes - the session's axis pair, when the caller holds one.
+ * @returns both axes in force.
+ */
+export declare function effectiveScopes(policy: SandboxExecutionPolicy, axes?: Partial<EffectiveScopes>): EffectiveScopes;
+/**
+ * Whether a policy's `mode` still spells its write scope's base — the
+ * invariant every construction site must preserve. A custom write scope whose
+ * base disagrees with `mode` would enforce containment the session never chose.
+ * @param policy - the policy to check.
+ * @param axes - the session's axis pair, when the caller holds one.
+ * @returns true when the two agree.
+ */
+export declare function isModeConsistent(policy: SandboxExecutionPolicy, axes?: Partial<EffectiveScopes>): boolean;
+//# sourceMappingURL=axis.d.ts.map

package/lib/types/config.d.ts

@@ -0,0 +1,173 @@
+/**
+ * The dual-axis settings surface: the 0.1.7 spelling of the section 0.1.6
+ * registered through `ctx.settings.installSection`.
+ *
+ * 0.1.7 removed both `installSection` and `settings.register(ns, schema)`:
+ * `SettingsForms.describe()` projects exactly the Config schemas of LOADED
+ * Loader entries (`packages/settings/settings/src/index.ts:302-340`) and
+ * `write()` refuses a namespace with no matching entry
+ * (`:382-384`, `No configurable plugin entry`). The namespace IS the entry
+ * id, so this package's own row id in `cordis.patch.yml` — `dual-axis` — is
+ * the settings namespace. 0.1.6's separate `sandbox-axis` namespace name is
+ * therefore retired.
+ *
+ * 0.1.7 also added the volatile gate: a field that is not beneath a
+ * `.volatile()` node is neither projected into the form
+ * (`packages/settings/settings/src/schema.ts:37-47`) nor writable
+ * (`:74-78`), and an entry with no volatile field at all is refused outright
+ * (`index.ts:385-386`). Both axes are marked volatile here.
+ *
+ * The schema is deliberately `z.any()` per axis, exactly as in 0.1.6:
+ * schemastery's union types strip the `custom` branch's `base/allow/deny`
+ * payload, which would silently degrade a configured custom axis into an axis
+ * carrying no paths. Shape validation is {@link normalizeScope}'s job.
+ *
+ * @module @t4r71/dsh-dual-axis/config
+ */
+import type { Context, Volatile } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { AxisScope } from './axis.ts';
+import type { RuleGroup } from './groups.ts';
+/**
+ * This package's row id in `cordis.patch.yml`. It doubles as the 0.1.7
+ * settings namespace (the Loader entry id) and, prefixed with the package
+ * name, as the `plugins.row.config` slot entry key the client half uses.
+ */
+export declare const DUAL_AXIS_ROW_ID = "dual-axis";
+/**
+ * The 0.1.6 settings namespace name, kept only so a migration can recognize
+ * the retired spelling. Nothing registers under it in 0.1.7.
+ */
+export declare const RETIRED_SETTINGS_NAMESPACE = "sandbox-axis";
+/**
+ * This row's composition config: the defaults a NEWLY CREATED session takes,
+ * plus the group library its `defaultGroups` are drawn from.
+ *
+ * Every field here is a SEED. A session reads this row once, when it is created,
+ * and owns its copy from then on; the decision paths (the fence and the prompt)
+ * read the row only to resolve, by id, the definitions of the groups a session
+ * already references ({@link groupLibraryValue}). Nothing here is consulted when
+ * an existing session decides whether a path is allowed.
+ *
+ * Fields left empty fall back to the built-in defaults (read `all`, write
+ * `workspace`, no groups), which are 0.1.6's `DEFAULT_READ_SCOPE` /
+ * `DEFAULT_WRITE_SCOPE`.
+ */
+export interface Config {
+    /** The read axis a new session starts from (default: `{ kind: 'all' }`). */
+    read?: Volatile<AxisScope>;
+    /** The write axis a new session starts from (default: `{ kind: 'workspace' }`). */
+    write?: Volatile<AxisScope>;
+    /** The group library: named rule fragments sessions reference by id (default: empty). */
+    groups?: Volatile<RuleGroup[]>;
+    /** Which of {@link groups} a new session starts out referencing (default: empty). */
+    defaultGroups?: Volatile<string[]>;
+}
+/**
+ * The composition config's schema. Both axes are `.volatile()` and
+ * `z.any()` — see the module docstring for why each is required.
+ *
+ * Not annotated `z<Config>`: `.volatile()` widens the field's inferred type
+ * to schemastery's `Volatile<>` accessor, which the plain `Config` interface
+ * does not describe. The repo's own volatile Configs
+ * (`packages/core/agent-default-model/src/index.ts:51-55`) are inferred the
+ * same way, and {@link axesOf} re-establishes the declared shape.
+ */
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    read: z<any, any, "volatile">;
+    write: z<any, any, "volatile">;
+    groups: z<NoInfer<any[]>, NoInfer<any[]>, "volatile-defined">;
+    defaultGroups: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    read: z<any, any, "volatile">;
+    write: z<any, any, "volatile">;
+    groups: z<NoInfer<any[]>, NoInfer<any[]>, "volatile-defined">;
+    defaultGroups: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+}>>, "plain">;
+/**
+ * Collect one `custom` axis's path list: every entry must be a non-empty
+ * absolute path.
+ * @param label - the axis name used in the error message.
+ * @param entry - the list name used in the error message (`allow` or `deny`).
+ * @param value - the untrusted list value.
+ * @returns the validated path list.
+ * @throws When the value is not a string array, or holds a non-absolute path.
+ */
+export declare function pathList(label: string, entry: string, value: unknown): readonly string[];
+/**
+ * Coerce one axis value from a config document (which a human may have edited)
+ * into a legal {@link AxisScope}, throwing rather than guessing.
+ *
+ * An unreadable axis must not become some other, wider or narrower grant:
+ * throwing fails the row's mount or the settings write on the spot instead of
+ * proceeding under an invented boundary. This is 0.1.6's `normalizeScope`,
+ * unchanged.
+ * @param label - the axis name used in error messages (`read` or `write`).
+ * @param value - the untrusted axis value.
+ * @returns the validated axis value.
+ * @throws When the value is not one of the four kinds, or a custom entry is not absolute.
+ */
+export declare function normalizeScope(label: string, value: unknown): AxisScope;
+/**
+ * Whether two axes describe the same boundary. Compared member by member
+ * rather than by reference: every re-parse builds fresh axis objects, and a
+ * custom axis's two path lists carry order as part of their value.
+ * @param left - one axis.
+ * @param right - another axis.
+ * @returns whether both describe the same axis.
+ */
+export declare function sameScope(left: AxisScope, right: AxisScope): boolean;
+/**
+ * Read both axes out of one settings/config value.
+ *
+ * The parameter is UNTRUSTED on purpose: the same function serves the
+ * composition layer's parsed Config, the settings service's projected
+ * descriptor (an `unknown` on the wire between two packages), and a
+ * hand-edited document, and none of those three is guaranteed to carry the
+ * declared shape. Both axes therefore pass through {@link normalizeScope},
+ * which is where an illegal value becomes a throw instead of an invented
+ * boundary; a missing side falls back to the built-in default axis.
+ * @param section - the section's current resolved value, whatever carries it.
+ * @returns both axes.
+ * @throws When either axis's shape is illegal.
+ */
+export declare function axesOf(section: unknown): {
+    read: AxisScope;
+    write: AxisScope;
+};
+/**
+ * This row's current value on the settings page, or `undefined` when no
+ * settings service is mounted.
+ *
+ * This is the ONE read path to that row. It goes through `describe()` rather
+ * than the config the plugin instance captured at mount because the loader does
+ * not commit a later save back to that instance
+ * (`vendor/loader/src/config/entry.ts:162-195`); `describe()` re-projects
+ * `entry.fiber.config` and unwraps the volatile accessors on every call
+ * (`packages/settings/settings/src/index.ts:319-323` +
+ * `packages/settings/settings/src/schema.ts:11`), which is the same path the
+ * settings page renders from. A save therefore applies without a restart.
+ * @param ctx - host context; the service is looked up, never injected.
+ * @returns the row's current value, or `undefined` when unavailable.
+ */
+export declare function declaredSection(ctx: Context): unknown;
+/**
+ * The group library a decision path may read, and the ONLY part of the settings
+ * row one may read for a decision.
+ *
+ * The row's `read`, `write` and `defaultGroups` fields are seeds for
+ * NEWLY CREATED sessions and carry no authority over an existing one; a
+ * decision path that read them would let the settings page silently re-scope a
+ * running session, which is the drift this package exists to prevent.
+ * @param section - the row's current value, as {@link declaredSection} returns it.
+ * @returns the untrusted `groups` value, for {@link resolveEffectiveAxes}.
+ */
+export declare function groupLibraryValue(section: unknown): unknown;
+/**
+ * The group ids a newly created session starts out referencing.
+ * @param section - the row's current value, as {@link declaredSection} returns it.
+ * @returns the ids, deduplicated; empty when the row declares none.
+ * @throws When a declared id is not a non-empty string.
+ */
+export declare function defaultGroupIds(section: unknown): readonly string[];
+//# sourceMappingURL=config.d.ts.map

package/lib/types/containment.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 目标路径包含判定：把上游 `@deepseek-ai/dsh-fs-sandbox/containment` 的
+ * `isPathUnder` 原样内联到本包。
+ *
+ * 为什么必须内联：fs-sandbox@0.1.7-rc.2 的**发布包** exports 只开出
+ * `.`、`./src/*` 与 `./package.json` 三条，**没有 `./containment`**；
+ * 而源码工作区里该文件存在，靠路径解析能直接命中。于是同一个 import 在
+ * 工作区里编译通过、装成 tgz 后运行期必然抛
+ * `Package subpath './containment' is not defined by "exports"`，
+ * 使 dual-axis 这个 entry 永远无法激活（fiberPhase 恒为 null）。
+ * 自有副本消除这个 install-shape 依赖。
+ * @module @t4r71/dsh-dual-axis/containment
+ */
+/**
+ * Determine whether a canonical target is a writable root or lies beneath it.
+ * The lexical fast path handles normal canonical spellings. When spellings
+ * differ, walk the target's existing ancestors and compare filesystem identity
+ * with the root; this recognizes Windows long-name/8.3 aliases and casing
+ * without weakening containment to a textual approximation.
+ * @param path - canonical target key, which may end in a missing suffix.
+ * @param root - canonical writable root.
+ * @param caseSensitive - whether lexical comparison preserves case; defaults
+ *   to the host filesystem convention used by supported platforms.
+ * @returns whether the target is the root or a descendant of it.
+ */
+export declare function isPathUnder(path: string, root: string, caseSensitive?: boolean): Promise<boolean>;
+//# sourceMappingURL=containment.d.ts.map

package/lib/types/content.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Whether a session has been USED yet — the one predicate that decides when its
+ * axis pair freezes.
+ *
+ * A session the workspace picker reopens in the same workspace is the same
+ * session id with the same stored record, so the axes it was seeded with at
+ * creation are what its two dropdowns show for the rest of its life. That is
+ * correct for a session someone has actually worked in; for one nobody has ever
+ * exchanged a turn with it is wrong, because the settings row is a live default
+ * and the person changing it expects the next conversation to follow.
+ *
+ * So the record is written when the session is used, not when it is created:
+ *
+ * - nothing appended beyond the loop's runtime-context snapshot → no record; the
+ *   seed recomputed from the CURRENT settings row answers every read, so the
+ *   dropdown follows the settings page in real time;
+ * - one real user turn, or an assistant reply → the record is written and the
+ *   pair freezes;
+ * - `/axis` → {@link SessionAxesStore.set} writes unconditionally, so a manual
+ *   pick always freezes, on an empty session too.
+ *
+ * ## What counts as "content"
+ *
+ * Everything except a message whose source is the loop's own runtime-context
+ * snapshot. That snapshot is appended by the agent loop on EVERY turn
+ * (`packages/core/agent-loop/src/runtime-context.ts`), including the very first
+ * one, and it is present before any human input exists — the four events a
+ * freshly created session carries are the header, the preset, the mode, and the
+ * approval policy. Counting it would make every session look used the moment
+ * anything rendered its prompt, which is exactly the state this predicate has to
+ * tell apart.
+ *
+ * The snapshot is identified by its `source.kind`, the discriminant the loop
+ * writes and reads back (`isOwned` in that module requires `kind === 'plugin'`;
+ * the system-prompt renderer stamps `kind: 'runtime-context'`). Matching on the
+ * kind is cheaper and more robust than matching the rendered text, which is
+ * localized prose that changes with every contribution.
+ *
+ * Every other message counts, the skill catalogue and the compaction markers
+ * included: each of them means the session has entered a turn, and a session
+ * that has entered a turn is one somebody is using.
+ *
+ * @module @t4r71/dsh-dual-axis/content
+ */
+import type { Session } from '@deepseek-ai/dsh-session';
+/**
+ * The event types that can carry content, so a listener can skip the rest without
+ * building the session's whole event list.
+ *
+ * A `system/message` is in here because it only exists once a turn has started,
+ * and a started turn is a used session. The prompt is assembled and that event
+ * appended BEFORE the human message reaches the log (measured: `system/message`
+ * at seq 7, the user turn at seq 8), so a rule that waited for the user message
+ * alone would let a tool-less turn finish without freezing anything.
+ */
+export declare const CONTENT_EVENT_TYPES: ReadonlySet<string>;
+/**
+ * Whether a session has content beyond the loop's own runtime-context snapshots.
+ *
+ * Cheap by construction: it walks the session's existing event array, which is
+ * already materialized and cached, without copying, parsing, or allocating per
+ * event. It is called on every `ensure` for a session that has no record, and
+ * that set is exactly the sessions nobody has used — so the scan is short.
+ * @param session - the session to judge.
+ * @returns whether this session has been used.
+ */
+export declare function hasContent(session: Session): boolean;
+//# sourceMappingURL=content.d.ts.map