@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/types/command-launcher.d.ts

@@ -1,104 +0,0 @@
-export type CommandLaunchRequest = {
-    id: string;
-    kind: "exec" | "exec_start" | "pty_open";
-    workspaceEffect?: "none";
-    /** An explicitly classified short coordination command; the launcher keeps a bounded lane for these. */
-    commandClass?: "control";
-    sessionId?: string;
-    assertAdmission: () => void;
-};
-export type CommandLaunchLane = "general" | "utility" | "control";
-export type CommandLaunchCapacity = {
-    generalSlots: number;
-    utilitySlots: number;
-    controlSlots: number;
-    controlRuntimeMs: number;
-    queueTimeoutMs: number;
-};
-export type CommandLaunchLaneReport = {
-    /** Null when no launcher bounds this lane (direct execution). */
-    slots: number | null;
-    active: Array<{
-        id: string;
-        sessionId?: string;
-        since: string;
-    }>;
-    queued: Array<{
-        id: string;
-        sessionId?: string;
-        since: string;
-    }>;
-};
-/** Who holds and who waits for each lane, as the worker sees its own admissions. */
-export type CommandLaunchCapacityReport = {
-    /** False for a direct worker: nothing is bounded and nothing can be starved. */
-    bounded: boolean;
-    controlRuntimeMs: number | null;
-    lanes: Record<CommandLaunchLane, CommandLaunchLaneReport>;
-};
-/** The same lane rule the managed launcher applies; kept here so reports match admissions. */
-export declare function commandLaunchLane(request: Pick<CommandLaunchRequest, "kind" | "workspaceEffect" | "commandClass">): CommandLaunchLane;
-export type CommandLaunchLease = {
-    wrap(argv: string[]): string[];
-    cancel(): Promise<void>;
-    diagnose(): Promise<string | undefined>;
-    release(): Promise<void>;
-};
-export declare class CommandLauncherUnavailableError extends Error {
-    constructor(message: string, cause?: unknown);
-}
-export declare class CommandLaunchCancelledError extends Error {
-    constructor();
-}
-export declare function parseCommandLauncher(configuration: string | undefined): string[] | undefined;
-/** Launcher configuration is operator-owned; do not inherit worker or package credentials. */
-export declare function commandLauncherEnvironment(source?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-/** Generic optional JSONL controller; policy and OS-specific launch prefixes live outside the worker. */
-export declare class WorkerCommandLauncher {
-    private readonly options;
-    readonly mode: "direct" | "external";
-    private readonly child?;
-    private readonly pending;
-    private readonly launches;
-    private readonly exited;
-    private failure?;
-    private closing;
-    private initialized;
-    private closePromise?;
-    private sequence;
-    private capacity?;
-    constructor(options?: {
-        argv?: string[];
-        env?: NodeJS.ProcessEnv;
-        onFailure?: (error: Error, ids: string[]) => void;
-        onStderr?: (text: string) => void;
-        requestTimeoutMs?: number;
-        acquisitionTimeoutMs?: number;
-        /** Called after any admission changes lane, phase, or is released. */
-        onCapacityChange?: () => void;
-    });
-    initialize(): Promise<void>;
-    get activeIds(): string[];
-    /** The lane totals the launcher declared at initialization; undefined for a direct worker or an older launcher. */
-    get declaredCapacity(): CommandLaunchCapacity | undefined;
-    get supportsControlLane(): boolean;
-    /** Current admissions per lane, for the worker's capacity report. */
-    capacityReport(): CommandLaunchCapacityReport;
-    private notifyCapacityChange;
-    acquire(request: CommandLaunchRequest): Promise<CommandLaunchLease>;
-    /** Revoke a launch. Returns whether this launcher still held it (queued or acquired, not yet released). */
-    cancel(id: string): Promise<boolean>;
-    cancelSession(sessionId: string): Promise<void>;
-    cancelMatching(matches: (id: string, sessionId?: string) => boolean): Promise<void>;
-    close(): Promise<void>;
-    private waitForExit;
-    private releaseRecord;
-    private assertHealthy;
-    private rpc;
-    private receive;
-    private rejectPending;
-    private fail;
-}
-export declare function createWorkerCommandLauncher(options?: Omit<NonNullable<ConstructorParameters<typeof WorkerCommandLauncher>[0]>, "argv"> & {
-    configuration?: string;
-}): Promise<WorkerCommandLauncher>;

package/dist/types/control-command-policy.d.ts

@@ -1,53 +0,0 @@
-/**
- * Which agent shell invocations may run in the managed launcher's bounded
- * `control` lane: exactly one plain `r5dctl` coordination/diagnosis command.
- *
- * The lane exists so an agent can inspect capacity, message another session,
- * or stop its own runs while every general slot is held by long work
- * (incident 9). It is bounded (small memory, few PIDs, a runtime limit), so
- * only commands that are short HTTP calls to the platform qualify. The
- * classifier fails closed: anything the shell would interpret (operators,
- * substitutions, expansions, quoting the tokenizer cannot prove literal,
- * environment assignments, wrapper programs, paths) is refused and keeps its
- * ordinary general-lane shell semantics. The resulting argv is validated a
- * second time by the worker before it is spawned without a shell.
- */
-export declare const CONTROL_COMMAND_PROGRAM = "r5dctl";
-/** Worker-side runtime bound for a control run; the launcher enforces its own limit as a backstop. */
-export declare const CONTROL_COMMAND_RUNTIME_MS = 120000;
-export declare const CONTROL_COMMAND_MAX_ARGV = 64;
-export declare const CONTROL_COMMAND_MAX_LENGTH = 4096;
-export type ControlCommandClassification = {
-    control: true;
-    argv: string[];
-} | {
-    control: false;
-    reason: string;
-};
-/**
- * Validate an argv as an allowed r5dctl coordination invocation. Used on the
- * server after tokenizing, and again on the worker before spawning.
- */
-export declare function assertControlCommandArgv(argv: readonly string[]): void;
-/**
- * Locate the installed CLI through the worker's own, operator-controlled
- * search path. The command's cwd, its environment, and any checkout-local
- * shim play no part, so a project cannot substitute the executable the
- * reserved lane runs.
- */
-export declare function resolveControlCommandExecutable(trustedPath: string | undefined, which: (program: string, options: {
-    PATH: string;
-}) => string | null, program?: string): string;
-/**
- * The environment a control spawn receives: everything the platform sets for
- * the run (credentials, session identity, declared project values) minus any
- * variable that could load code into the CLI process or redirect which
- * executable runs, with the worker's own PATH restored.
- */
-export declare function controlCommandEnvironment(environment: NodeJS.ProcessEnv, trustedPath: string | undefined): Record<string, string>;
-/**
- * Classify an agent shell command. Only a plain `r5dctl` coordination
- * invocation becomes a control command; the returned argv is spawned without a
- * shell. Everything else keeps its ordinary shell semantics and lane.
- */
-export declare function classifyControlCommand(command: string): ControlCommandClassification;

package/dist/types/git-blob-hash.d.ts

@@ -1,10 +0,0 @@
-export type GitObjectHashAlgorithm = "sha1" | "sha256";
-/** The object format an object id of this length belongs to, or null for anything that is not an object id. */
-export declare function gitObjectHashAlgorithmFor(objectId: string): GitObjectHashAlgorithm | null;
-/**
- * The id `git hash-object` gives `content` as a blob: the hash of the
- * `blob <size>\0` header followed by the bytes, with no filter applied. The
- * sync engine hashes checkout bytes with it to ask whether a file still holds
- * what a commit records without spawning git.
- */
-export declare function gitBlobHash(content: Buffer, algorithm: GitObjectHashAlgorithm): string;

package/dist/types/git-identity.d.ts

@@ -1,9 +0,0 @@
-export type WorkerGitIdentity = {
-    name: string;
-    email: string;
-};
-type RunGit = (args: string[], options?: {
-    cwd?: string;
-}) => string | void;
-export declare function configureVisibleGitIdentity(branchPath: string, identity: WorkerGitIdentity | null | undefined, runGit: RunGit): void;
-export {};

package/dist/types/git-process-environment.d.ts

@@ -1,9 +0,0 @@
-/** Build the complete environment for a worker-owned Git child process. */
-export declare function workerGitProcessEnvironment(source?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-/** Clear inherited and repository-local HTTP authorization headers for one transport URL. */
-export declare function gitHttpAuthorizationClearArgs(remoteUrl: string): string[];
-/** Select only the app-owned credential store, regardless of repository-local helpers. */
-export declare function gitCredentialHelperConfigArgs(credentialHelper?: string | null): string[];
-export declare function gitCredentialUsernameConfigKey(remoteUrl: string): string;
-/** Non-secret command configuration required for an authenticated HTTP transport. */
-export declare function gitTransportSecurityArgs(remoteUrl: string, credentialHelper?: string | null, credentialUsername?: string | null): string[];

package/dist/types/inline-output.d.ts

@@ -1,3 +0,0 @@
-export declare const WORKER_INLINE_OUTPUT_MAX_BYTES: number;
-/** Bound inline RPC buffers in the worker regardless of child launch policy. */
-export declare function collectWorkerInlineOutput(stream: ReadableStream<Uint8Array> | null, maxBytes?: number, signal?: AbortSignal): Promise<string>;

package/dist/types/managed-paths.d.ts

@@ -1,19 +0,0 @@
-export declare const BRANCH_NAME_MAX_LENGTH = 45;
-export declare const BRANCH_NAME_PATTERN: RegExp;
-export type CheckoutPathSegments = [namespace: string, project: string];
-export type ManagedRoot = {
-    label: string;
-    rootPath: string;
-};
-/**
- * Destructive worker roots must never alias or contain one another. Resolve
- * and materialize every root first so symlinks, bind mounts, casing aliases,
- * and Unicode-normalization aliases cannot disguise an overlap. This runs
- * before any snapshot recovery or other destructive filesystem operation.
- */
-export declare function assertDisjointManagedRoots(roots: readonly ManagedRoot[]): void;
-export declare function validateManagedBranchName(branchName: string): void;
-export declare function validateCheckoutPathSegments(value: unknown): CheckoutPathSegments;
-export declare function assertPathInside(root: string, candidate: string, label: string): void;
-export declare function managedProjectRoot(projectsRoot: string, checkoutPathSegments: unknown): string;
-export declare function managedBranchPath(projectsRoot: string, checkoutPathSegments: unknown, branchName: string): string;

package/dist/types/plan-lint.d.ts

@@ -1,16 +0,0 @@
-export interface PlanLintError {
-    planId: string;
-    message: string;
-    severity: "warning" | "error";
-    line?: number;
-}
-export interface PlanLintResult {
-    type: "plan_lint";
-    errors: PlanLintError[];
-    errorCount: number;
-    warningCount: number;
-    lintedPlanCount: number;
-}
-export declare function lintPlanContent(planId: string, content: string): PlanLintError[];
-export declare function lintPlans(plansDir: string, glob?: string): Promise<PlanLintResult>;
-export declare function formatPlanLintErrors(errors: PlanLintError[]): string;

package/dist/types/plan-parser.d.ts

@@ -1,38 +0,0 @@
-/**
- * Markdown plan parser.
- *
- * Plans are plain Markdown files. The only structured region is the first
- * "## Tasks" section, which contains checkbox task lines.
- */
-export declare const PLAN_TASK_ID_REGEX: RegExp;
-export declare const PLAN_TASK_LINE_REGEX: RegExp;
-export declare const PLAN_TASKS_HEADING_REGEX: RegExp;
-export interface PlanTask {
-    id: string;
-    description: string;
-    checked: boolean;
-    lineNumber: number;
-}
-export interface ParsedPlan {
-    id: string;
-    title: string;
-    content: string;
-    tasks: PlanTask[];
-    currentTask: PlanTask | null;
-    complete: boolean;
-    tasksStartLine: number | null;
-    tasksEndLine: number | null;
-}
-export type ParsedMarkdownPlan = ParsedPlan;
-export declare function getPlanMetadata(content: string): {
-    title: string;
-};
-export declare function getTasksSectionRange(content: string): {
-    startIndex: number;
-    endIndex: number;
-} | null;
-export declare function parseMarkdownPlan(content: string, planId: string): ParsedPlan;
-export declare const parsePlan: typeof parseMarkdownPlan;
-export declare function createPlanMarkdown(planId: string, title?: string): string;
-export declare function updateTaskCheckbox(content: string, taskId: string, checked: boolean): string;
-export declare function formatPlanTitle(planId: string): string;

package/dist/types/plan-paths.d.ts

@@ -1,36 +0,0 @@
-type PlanTarget = {
-    type: "project";
-} | {
-    type: "workspace";
-    rootProfile: "visible_projects" | "canonical_sync";
-};
-export declare const PLAN_EXTENSION = ".plan.md";
-export declare function validatePlanId(planId: string): void;
-export declare function assertPlanTarget(target: PlanTarget): void;
-export declare function getWorkerPlansPath(target: PlanTarget): string;
-/** The same worker path is used in prompts, injected reads, and file tools. */
-export declare function getWorkerPlanPath(target: PlanTarget, planId: string): string;
-export type WorkerReadPlanInput = {
-    planId: string;
-    createIfMissing: boolean;
-};
-export type WorkerLintPlansInput = {
-    glob?: string;
-};
-export type WorkerUpdatePlanTaskInput = {
-    planId: string;
-    taskId: string;
-    checked: boolean;
-};
-export type WorkerLintPlansResult = {
-    type: "lint_plans";
-    content: string;
-};
-export type WorkerUpdatePlanTaskResult = {
-    type: "update_task_status";
-    planId: string;
-    taskId: string;
-    checked: boolean;
-    message: string;
-};
-export {};

package/dist/types/port-forward-client.d.ts

@@ -1,8 +0,0 @@
-export declare function openWorkerPortForwardRelay(options: {
-    baseUrl: string;
-    token: string;
-    label: string;
-    forwardId: string;
-    relayConnectionId: string;
-    workerPort: number;
-}): void;

package/dist/types/project-checkout-garbage.d.ts

@@ -1,86 +0,0 @@
-/**
- * Where a deleted branch checkout waits for collection. Staging is the only
- * platform write into this directory and a live checkout always lives at
- * `<projectRoot>/<branch>`, so a crash between staging and collection leaves
- * nothing that a later sweep could confuse with a replacement branch. The
- * filesystem is user-managed, though, so the collector never trusts the name
- * alone: it removes only real directories or leaf links that sit under a real
- * garbage directory of a real project directory (see `ownedStagedPath`).
- * Distinct from `.r5d-removed`, which preserves paths that were not this
- * project's worktree.
- */
-export declare const PROJECT_DELETED_CHECKOUTS_DIRECTORY = ".r5d-deleted";
-/**
- * Rename a checkout this project owns out of the active namespace. One
- * same-filesystem rename takes milliseconds whatever the tree holds, so the
- * branch mutation lease is released long before the bytes are gone. The
- * garbage directory must be a real directory: a planted link would make the
- * later collection walk through it, so staging refuses rather than continue.
- */
-export declare function stageProjectCheckoutForDeletion(projectRoot: string, branchName: string, checkoutPath: string): string;
-/**
- * Rename a whole project root out of the active namespace, into the
- * namespace's garbage directory, so removing a deleted project never walks
- * its checkouts on the worker event loop. Same guarantees as
- * stageProjectCheckoutForDeletion: one same-filesystem rename, a real garbage
- * directory, collection by the garbage collector later.
- */
-export declare function stageProjectForDeletion(projectsRoot: string, projectRoot: string): string;
-/**
- * True when `candidate` is lexically a direct entry of a project's garbage
- * directory (`<namespace>/<project>/.r5d-deleted/<entry>`, a staged checkout)
- * or of a namespace's garbage directory (`<namespace>/.r5d-deleted/<entry>`,
- * a staged whole project) under `projectsRoot`.
- */
-export declare function isStagedProjectCheckoutPath(projectsRoot: string, candidate: string): boolean;
-/**
- * Whether a lexically staged path is safe to remove right now: every ancestor
- * below the projects root is a real directory (a linked namespace, project,
- * or garbage directory would let a removal reach an unrelated tree through
- * the link), and the entry itself is a real directory or a leaf link. Checked
- * again immediately before the removal starts, never only at enqueue time.
- */
-export declare function ownedStagedPath(projectsRoot: string, candidate: string): {
-    kind: "directory" | "link";
-} | null;
-/**
- * Every owned staged checkout under `<projectsRoot>/<namespace>/<project>/.r5d-deleted/`
- * and every owned staged project under `<projectsRoot>/<namespace>/.r5d-deleted/`;
- * linked ancestors are not followed.
- */
-export declare function discoverStagedProjectCheckouts(projectsRoot: string): string[];
-/**
- * Delete a staged tree in a child process so a large recursive removal never
- * runs on the worker event loop, at the lowest CPU and (where supported) I/O
- * priority so live agents on the same volume keep their share. A leaf link is
- * unlinked in place; its target is never followed.
- */
-export declare function removeStagedProjectCheckout(stagedPath: string): Promise<void>;
-type Logger = (message: string) => void;
-/**
- * Collects staged checkouts one at a time, outside every workspace lease.
- * Entries are enqueued right after staging and by `sweep()` at worker start,
- * so a crash at any point converges on the next start. A failed removal is
- * logged and left for the next sweep.
- */
-export declare class ProjectCheckoutGarbageCollector {
-    private readonly projectsRoot;
-    private readonly remove;
-    private readonly log;
-    private readonly queued;
-    private tail;
-    private collectedCount;
-    constructor(options: {
-        projectsRoot: string;
-        remove?: (stagedPath: string) => Promise<void>;
-        log?: Logger;
-    });
-    /** Number of removals that have completed successfully. */
-    get collected(): number;
-    /** Resolves once everything queued so far has been attempted. */
-    get idle(): Promise<void>;
-    enqueue(stagedPath: string): void;
-    /** Enqueue every staged checkout left behind by an earlier process. */
-    sweep(): number;
-}
-export {};

package/dist/types/project-mirror-fetch-policy.d.ts

@@ -1,84 +0,0 @@
-/**
- * Decides which part of a project's hidden mirror a periodic observation must
- * fetch, from the tokens the server advertises and the tokens the worker's
- * own mirror refs cover (both computed with `project-mirror-refs-token.ts`).
- *
- * Skipping is fail-open: any missing or mismatched information fetches.
- *
- * There is deliberately no timed backstop refetch for matching tokens. The
- * server recomputes every advertised token from the canonical repository on
- * disk on each heartbeat sweep, so a matching token is a fresh statement that
- * the fetch would transfer nothing, whoever moved the refs. The worker
- * records the tokens it covers from its own refs after every fetch and lease
- * push, with the same shared formula, so a skip can only be stale if the
- * canonical repository moved after the sweep that produced the advertisement
- * — which the next sweep corrects, exactly like a tip that lands mid-cycle —
- * or if the formula itself were wrong, which the shared module and its locked
- * vectors guard and a periodic blind fetch would only hide. A project or
- * mount the server advertises no token for fetches every cycle, as before
- * tokens existed.
- */
-/** Why a fetch runs. `fail_closed` is never decided here: reset and remediation observation bypasses the gate. */
-export type ProjectMirrorFetchReason = "skipping_disabled" | "no_advertised_token" | "never_fetched" | "token_changed" | "fail_closed";
-export type ProjectMirrorFetchDecision = {
-    fetch: true;
-    reason: ProjectMirrorFetchReason;
-} | {
-    fetch: false;
-    reason: "token_match";
-};
-export declare function projectMirrorFetchDecision(input: {
-    advertisedToken: string | undefined;
-    fetchedToken: string | undefined;
-    skippingEnabled: boolean;
-}): ProjectMirrorFetchDecision;
-export type ProjectMirrorObservationFetchPlan = 
-/** Fetch every canonical ref of the project, as observation always did before per-mount tokens. */
-{
-    scope: "project";
-    reason: ProjectMirrorFetchReason;
-}
-/** Fetch only the named mounts' branch heads and handoff refs. */
- | {
-    scope: "mounts";
-    mounts: Array<{
-        branchName: string;
-        reason: ProjectMirrorFetchReason;
-    }>;
-}
-/** Every token the observation depends on matches; reuse the local refs. */
- | {
-    scope: "none";
-};
-/**
- * Plan one project's observation fetch. With per-mount tokens advertised for
- * the project, each mount decides for itself and only changed mounts fetch;
- * without them (an older server) the project token decides for the whole
- * mirror.
- */
-export declare function planProjectMirrorObservationFetch(input: {
-    branchNames: readonly string[];
-    advertisedProjectToken: string | undefined;
-    /** Per-mount tokens for this project, keyed by branch name; undefined when the server advertised none. */
-    advertisedMountTokens: ReadonlyMap<string, string> | undefined;
-    fetchedProjectToken: string | undefined;
-    fetchedMountTokens: ReadonlyMap<string, string>;
-    skippingEnabled: boolean;
-}): ProjectMirrorObservationFetchPlan;
-export type ProjectMirrorRefsTokensAdvertisement = {
-    /** One token per project id. */
-    projectTokens: Map<string, string>;
-    /** Per-mount tokens keyed by project id then branch name; a project is present only when the server advertised mount tokens for it. */
-    mountTokens: Map<string, Map<string, string>>;
-    /** Current head of the user's hidden workspace repository, when advertised. */
-    workspaceHead: string | undefined;
-};
-/**
- * Read a `project_mirror_refs_tokens` message. Older servers send only
- * `tokens`; malformed entries are dropped, which fails open into fetching.
- */
-export declare function parseProjectMirrorRefsTokensMessage(message: {
-    tokens?: unknown;
-    mountTokens?: unknown;
-    workspaceHead?: unknown;
-}): ProjectMirrorRefsTokensAdvertisement;

package/dist/types/project-mirror-refs-token.d.ts

@@ -1,53 +0,0 @@
-/** Canonical namespaces the token hashes; also the observation fetch's sources. */
-export declare const PROJECT_MIRROR_REFS_TOKEN_NAMESPACES: readonly ["refs/heads/", "refs/r5d/server-synced/"];
-/** Worker-local copy of a canonical `refs/heads/*` ref. */
-export declare const PROJECT_MIRROR_REF_PREFIX = "refs/r5d/mirror/";
-export declare const PROJECT_SERVER_SYNCED_REF_PREFIX = "refs/r5d/server-synced/";
-/** `git for-each-ref` format both sides list refs with; see parseProjectMirrorRefListing. */
-export declare const PROJECT_MIRROR_REF_LISTING_FORMAT = "--format=%(objectname) %(refname)";
-export type ProjectMirrorRef = {
-    refname: string;
-    objectName: string;
-};
-/** One checked-out project branch, identified by its durable incarnation id. */
-export type ProjectMirrorMount = {
-    branchName: string;
-    branchId: string;
-};
-export type ProjectMirrorRefsTokens = {
-    /** Hash over every ref in the observed namespaces. */
-    project: string;
-    /** Hash over one mount's branch head plus its handoff refs, keyed by branch name. */
-    mounts: Map<string, string>;
-};
-/**
- * Hash a ref listing into a mirror-refs token. Both sides sort here rather
- * than trusting git's listing order: renaming `refs/r5d/mirror/*` back to
- * `refs/heads/*` changes sort neighborhoods.
- */
-export declare function hashProjectMirrorRefs(refs: readonly ProjectMirrorRef[]): string;
-/**
- * Parse `git for-each-ref` output produced with
- * PROJECT_MIRROR_REF_LISTING_FORMAT. Malformed rows throw rather than being
- * dropped: a caller that cannot trust its listing must not produce a token.
- * With `namespaces`, rows outside them throw too.
- */
-export declare function parseProjectMirrorRefListing(output: string, options?: {
-    namespaces?: readonly string[];
-}): ProjectMirrorRef[];
-/**
- * Rename locally fetched mirror refs into the namespaces the server hashes.
- * Rows outside the two observed namespaces are dropped; the caller lists only
- * those namespaces, so a dropped row means an unexpected listing, and dropping
- * it can only make tokens differ — which fails open into a fetch.
- */
-export declare function canonicalizeLocalProjectMirrorRefs(refs: readonly ProjectMirrorRef[]): ProjectMirrorRef[];
-/** The canonical refs one mount's token covers: its branch head and its server-synced handoff refs. */
-export declare function projectMirrorMountRefs(refs: readonly ProjectMirrorRef[], mount: ProjectMirrorMount): ProjectMirrorRef[];
-/**
- * Compute the project token and one token per mount from one canonical ref
- * listing. A mount's token is the project formula applied to the mount's own
- * refs, so a mount whose branch is the only ref of its project has the same
- * token as the project.
- */
-export declare function projectMirrorRefsTokens(refs: readonly ProjectMirrorRef[], mounts: readonly ProjectMirrorMount[]): ProjectMirrorRefsTokens;