akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/core/closest-match.js

@@ -0,0 +1,37 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * The closest of a few known names to one that was typed, for a did-you-mean in
+ * an error: the unknown-flag and unknown-command paths, an improve scope's type,
+ * and a connection or harness that is not configured.
+ */
+/** Single-row-at-a-time edit-distance DP (inputs are short flag/command names). */
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i += 1) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j += 1) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            current.push(Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, (previous[j - 1] ?? 0) + cost));
+        }
+        previous = current;
+    }
+    return previous[b.length] ?? 0;
+}
+/**
+ * Closest candidate within `threshold` edit distance, or undefined when
+ * nothing is close enough to be worth suggesting. Callers pick their own thresholds.
+ */
+export function closestMatch(attempted, candidates, threshold) {
+    let best;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+        const distance = editDistance(attempted, candidate);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = candidate;
+        }
+    }
+    return best !== undefined && bestDistance <= threshold ? best : undefined;
+}

package/dist/core/common.js

@@ -86,8 +86,9 @@ export function readTextFile(filePath, label = "File") {
  */
 /**
  * Strip JavaScript-style comments from a JSON string (JSONC support).
- * Handles `//` line comments and `/* *​/` block comments while preserving
- * comment-like sequences inside quoted strings.
+ * Handles `//` line comments, which end at a line feed or a carriage return,
+ * and `/* *​/` block comments while preserving comment-like sequences inside
+ * quoted strings.
  */
 export function stripJsonComments(text) {
     let result = "";
@@ -114,7 +115,7 @@ export function stripJsonComments(text) {
             continue;
         }
         if (text[i] === "/" && text[i + 1] === "/") {
-            while (i < text.length && text[i] !== "\n")
+            while (i < text.length && text[i] !== "\n" && text[i] !== "\r")
                 i++;
             continue;
         }
@@ -313,7 +314,7 @@ function readStashDirFromConfig() {
         if (typeof parsed !== "object" || parsed === null)
             return undefined;
         const raw = parsed;
-        // 0.9.0 config-shape cutover (spec §10.1): the primary stash is the
+        // The primary stash is the
         // `defaultBundle`'s filesystem `path`. Read it directly (no config module
         // import) so the primary-stash location survives the stashDir → bundles
         // migration without a runtime rewire.
@@ -376,25 +377,6 @@ export function hasErrnoCode(error, code) {
 export function isChmodUnsupported(error) {
     return hasErrnoCode(error, "EPERM") || hasErrnoCode(error, "ENOTSUP") || hasErrnoCode(error, "EINVAL");
 }
-/**
- * True when `value` is a RELATIVE path that cannot leave its base directory:
- * no absolute form (POSIX `/`, Windows `\` or a `C:` drive prefix), no `~`
- * home expansion, and no `..` segment under either separator.
- *
- * This is the SYNTACTIC half of containment — cheap, string-only, usable at
- * authoring time before any directory exists. It is deliberately paired with
- * (never a substitute for) {@link isWithin}, which resolves symlinks against a
- * real base at use time. Workflow `exec` units run both: the parser and the
- * frozen-plan decoder reject uncontained spellings, and the executor re-checks
- * the resolved path before spawning.
- */
-export function isContainedRelativePath(value) {
-    if (value === "" || value.startsWith("/") || value.startsWith("\\") || value.startsWith("~"))
-        return false;
-    if (/^[A-Za-z]:/.test(value))
-        return false;
-    return !value.split(/[/\\]+/).includes("..");
-}
 export function isWithin(candidate, root) {
     return isContainedResolvedPath(safeRealpath(candidate), safeRealpath(root));
 }
@@ -419,16 +401,11 @@ export function isAkmRegistryCachePath(filePath) {
     return isWithin(filePath, getRegistryCacheDir()) || isWithin(filePath, getRegistryIndexCacheDir());
 }
 /**
- * {@link isWithin} for callers that must not block the event loop (e.g. the
- * workflow exec dispatch path, which runs once per fan-out unit). Same
- * comparison, same normalization, same nearest-existing-ancestor fallback —
- * only the realpath syscalls are awaited.
+ * The containment comparison behind {@link isWithin}.
+ * Called directly with `path.resolve`d arguments it is a lexical check: it
+ * refuses `..` and absolute names without following symlinks.
  */
-export async function isWithinAsync(candidate, root) {
-    return isContainedResolvedPath(await safeRealpathAsync(candidate), await safeRealpathAsync(root));
-}
-/** The containment comparison shared by {@link isWithin} and {@link isWithinAsync}. */
-function isContainedResolvedPath(resolvedCandidate, resolvedRoot) {
+export function isContainedResolvedPath(resolvedCandidate, resolvedRoot) {
     const rel = path.relative(normalizeFsPathForComparison(resolvedRoot), normalizeFsPathForComparison(resolvedCandidate));
     if (rel === "")
         return true;
@@ -475,30 +452,6 @@ export function safeRealpath(p) {
         }
     }
 }
-/** {@link safeRealpath}'s async twin — awaited syscalls, identical walk-up. */
-export async function safeRealpathAsync(p) {
-    const resolved = path.resolve(p);
-    try {
-        return await fs.promises.realpath(resolved);
-    }
-    catch {
-        const suffix = [];
-        let current = resolved;
-        for (;;) {
-            const parent = path.dirname(current);
-            if (parent === current)
-                return resolved;
-            suffix.unshift(path.basename(current));
-            current = parent;
-            try {
-                return path.join(await fs.promises.realpath(current), ...suffix);
-            }
-            catch {
-                // parent also doesn't exist; keep walking up
-            }
-        }
-    }
-}
 function normalizeFsPathForComparison(value) {
     return process.platform === "win32" ? value.toLowerCase() : value;
 }
@@ -938,6 +891,33 @@ export function isRecord(value) {
 export function asRecord(value) {
     return isRecord(value) ? value : undefined;
 }
+/** Drop each comma that is followed, past whitespace, by `}` or `]`, outside string literals. */
+function stripTrailingCommas(text) {
+    let result = "";
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (inString) {
+            result += char;
+            if (char === "\\")
+                result += text[++i] ?? "";
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"')
+            inString = true;
+        else if (char === ",") {
+            let next = i + 1;
+            while (next < text.length && /\s/.test(text[next]))
+                next++;
+            if (text[next] === "}" || text[next] === "]")
+                continue;
+        }
+        result += char;
+    }
+    return result;
+}
 /**
  * Parse JSONC: comments stripped by {@link stripJsonComments}, and trailing
  * commas (`[a, b,]`, `{"k": 1,}`) tolerated, as OpenCode's own `.jsonc` reader does.
@@ -948,7 +928,7 @@ export function parseJsonc(text) {
         return JSON.parse(stripped);
     }
     catch {
-        return JSON.parse(stripped.replace(/,(\s*[}\]])/g, "$1"));
+        return JSON.parse(stripTrailingCommas(stripped));
     }
 }
 /** `JSON.parse` that returns `undefined` instead of throwing. */

package/dist/core/config/config-io.js

@@ -83,6 +83,24 @@ const MAX_CONFIG_BACKUPS = 5;
 export function backupExistingConfig(configPath, now = new Date()) {
     if (!fs.existsSync(configPath))
         return undefined;
+    const timestamped = copyToConfigBackups(configPath, (stamp) => `config-${stamp}.json`, now);
+    const backupDir = path.dirname(timestamped);
+    const latest = path.join(backupDir, "config.latest.json");
+    fs.copyFileSync(configPath, latest);
+    // 08-F4: a config backup carries the same sensitive fields as the live config
+    // (endpoints, tokens). `copyFileSync` inherits the source's (often 0644) mode,
+    // so tighten the backups to owner-only — mirrors the env-cli 0600 write floor.
+    chmodIfSupported(latest, 0o600);
+    pruneOldBackups(backupDir);
+    return { timestamped, latest };
+}
+/**
+ * Copy `source` into `<cacheDir>/config-backups/` as `name(stamp)`, where `stamp` is the
+ * timestamp of `now` and gets a `-1`, `-2`, ... when that name is taken, and return where it
+ * went. The directory is owner-only (0700) and so is the copy (0600). The one place a backup is
+ * named, for the config file and the credential store alike.
+ */
+export function copyToConfigBackups(source, name, now = new Date()) {
     const backupDir = path.join(getCacheDir(), "config-backups");
     // 08-F4: lock the backup dir owner-only up front (0700) — matching the
     // env.ts/secret.ts convention — so no other local user can traverse in during
@@ -90,29 +108,19 @@ export function backupExistingConfig(configPath, now = new Date()) {
     fs.mkdirSync(backupDir, { recursive: true, mode: 0o700 });
     chmodIfSupported(backupDir, 0o700);
     const timestamp = now.toISOString().replace(/[.:]/g, "-");
-    let sequence = 0;
-    let timestamped;
-    while (true) {
-        timestamped = path.join(backupDir, `config-${timestamp}${sequence === 0 ? "" : `-${sequence}`}.json`);
+    for (let sequence = 0;; sequence += 1) {
+        const target = path.join(backupDir, name(sequence === 0 ? timestamp : `${timestamp}-${sequence}`));
         try {
-            fs.copyFileSync(configPath, timestamped, fs.constants.COPYFILE_EXCL);
-            break;
+            fs.copyFileSync(source, target, fs.constants.COPYFILE_EXCL);
         }
         catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            sequence++;
+            if (error.code === "EEXIST")
+                continue;
+            throw error;
         }
+        chmodIfSupported(target, 0o600);
+        return target;
     }
-    const latest = path.join(backupDir, "config.latest.json");
-    fs.copyFileSync(configPath, latest);
-    // 08-F4: a config backup carries the same sensitive fields as the live config
-    // (endpoints, tokens). `copyFileSync` inherits the source's (often 0644) mode,
-    // so tighten the backups to owner-only — mirrors the env-cli 0600 write floor.
-    chmodIfSupported(timestamped, 0o600);
-    chmodIfSupported(latest, 0o600);
-    pruneOldBackups(backupDir);
-    return { timestamped, latest };
 }
 /** chmod, skipped on a filesystem without POSIX modes (CIFS), where the mount sets them. */
 function chmodIfSupported(target, mode) {

package/dist/core/config/config-schema.js

@@ -5,7 +5,7 @@
  * Zod schema for AkmConfig — the single source of truth for the on-disk shape.
  *
  * ASSEMBLY BARREL: the individual section schemas live under `./schema/*` (one
- * cohesive module per config area — engines, embedding, improve, sources/
+ * cohesive module per config area — connections, harnesses, embedding, improve, sources/
  * bundles, index, search, output, feedback, workflow, setup, plus shared
  * `primitives`). This file assembles them into the top-level {@link AkmConfigShape}
  * / {@link AkmConfigSchema}, owns the cross-field {@link AkmConfigSchema.superRefine},
@@ -31,7 +31,7 @@
  *   silently dropping them would mask user data loss.
  * - UNKNOWN-KEY POLICY: portable descriptive sections generally use
  *   passthrough so version skew round-trips newer settings. Small finite
- *   authority/toggle sections (`scheduler`, `execution`, `experimental`, and
+ *   authority/toggle sections (`scheduler`, `experimental`, and
  *   reranker policy) are strict: a misspelling there must not silently turn a
  *   safety decision off. The top level remains passthrough and warns on
  *   unknown keys.
@@ -39,28 +39,28 @@
  *   enforced at save time via `superRefine` on the top-level schema.
  */
 import { z } from "zod";
-import { HARNESS_MODEL_WORK_IDS } from "../../integrations/harnesses/index.js";
-import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_ENGINE_PROCESSES, REMOVED_IMPROVE_STRATEGY_NAMES, } from "./engine-semantics.js";
+import { BUILTIN_IMPROVE_STRATEGY_NAMES, REMOVED_IMPROVE_STRATEGY_NAMES } from "./engine-semantics.js";
+import { ConnectionsSchema } from "./schema/connections.js";
 import { EmbeddingConnectionConfigSchema } from "./schema/embedding.js";
-import { EnginesSchema } from "./schema/engines.js";
-import { ExecutionPolicyConfigSchema } from "./schema/execution.js";
 import { ExperimentalConfigSchema } from "./schema/experimental.js";
 import { FeedbackConfigSchema } from "./schema/feedback.js";
+import { HarnessesSchema } from "./schema/harnesses.js";
 import { ImproveConfigSchema } from "./schema/improve.js";
 import { IndexConfigSchema } from "./schema/index-config.js";
 import { OutputConfigSchema } from "./schema/output.js";
-import { CURRENT_CONFIG_VERSION, engineName, nonEmptyString, nonNegativeNumber } from "./schema/primitives.js";
+import { CURRENT_CONFIG_VERSION, nonEmptyString, nonNegativeNumber } from "./schema/primitives.js";
 import { SchedulerConfigSchema } from "./schema/scheduler.js";
 import { SearchConfigSchema } from "./schema/search.js";
 import { SetupConfigSchema } from "./schema/setup.js";
 import { BundlesConfigSchema, RegistryConfigEntrySchema } from "./schema/sources-bundles.js";
 import { WorkflowConfigSchema } from "./schema/workflow.js";
 // ── Section re-exports (keep every `./config-schema` import path working) ────
+export { ConnectionSchema, ConnectionsSchema } from "./schema/connections.js";
 export { EmbeddingConnectionConfigSchema } from "./schema/embedding.js";
-export { EngineConfigSchema, EnginesSchema, LlmConnectionConfigSchema, LlmProfileConfigSchema } from "./schema/engines.js";
 export { ExperimentalConfigSchema } from "./schema/experimental.js";
 export { FeedbackConfigSchema } from "./schema/feedback.js";
-export { ImproveConfigSchema } from "./schema/improve.js";
+export { HarnessesSchema } from "./schema/harnesses.js";
+export { ImproveConfigSchema, ImproveWhereSchema } from "./schema/improve.js";
 export { ConsolidateProcessConfigSchema, DistillProcessConfigSchema, ExtractProcessConfigSchema, ImproveProcessConfigSchema, ImproveProfileConfigSchema, MemoryInferenceProcessConfigSchema, ProactiveMaintenanceProcessConfigSchema, ReflectProcessConfigSchema, TriageProcessConfigSchema, ValidationProcessConfigSchema, } from "./schema/improve-processes.js";
 export { IndexConfigSchema, IndexPassConfigSchema } from "./schema/index-config.js";
 export { OutputConfigSchema } from "./schema/output.js";
@@ -70,14 +70,6 @@ export { SearchConfigSchema } from "./schema/search.js";
 export { SetupConfigSchema } from "./schema/setup.js";
 export { BundleConfigEntrySchema, BundlesConfigSchema, RegistryConfigEntrySchema, SourceConfigEntrySchema, } from "./schema/sources-bundles.js";
 export { WorkflowConfigSchema } from "./schema/workflow.js";
-// ── Defaults ───────────────────────────────────────────────────────────────
-export const DefaultsSchema = z
-    .object({
-    engine: engineName.optional(),
-    llmEngine: engineName.optional(),
-    improveStrategy: engineName.optional(),
-})
-    .passthrough();
 // ── Top-level AkmConfig ────────────────────────────────────────────────────
 /**
  * Base object schema used both as the top-level shape and as the source of
@@ -104,12 +96,10 @@ export const AkmConfigShape = {
     // `resolveExtendsChain` (./config.ts), not validated here (a bad ref
     // surfaces as a `ConfigError` at load, naming the ref).
     extends: nonEmptyString.optional(),
-    engines: EnginesSchema.optional(),
-    defaults: DefaultsSchema.optional(),
+    connections: ConnectionsSchema.optional(),
+    harnesses: HarnessesSchema.optional(),
     semanticSearchMode: z.enum(["off", "auto"]).default("off"),
     embedding: EmbeddingConnectionConfigSchema.optional(),
-    // Host-local execution authority. Inherited layers are stripped.
-    execution: ExecutionPolicyConfigSchema.optional(),
     index: IndexConfigSchema.optional(),
     registries: z.array(RegistryConfigEntrySchema).optional(),
     // `bundles` + `defaultBundle` are the only source configuration shape. The
@@ -197,103 +187,26 @@ export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) =>
             });
         }
     }
-    for (const [name, engine] of Object.entries(config.engines ?? {})) {
-        if (engine.kind === "agent" && engine.llmEngine) {
-            const fallback = config.engines?.[engine.llmEngine];
-            if (!fallback || fallback.kind !== "llm") {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: ["engines", name, "llmEngine"],
-                    message: "llmEngine must name an LLM engine",
-                });
-            }
-        }
-    }
-    const defaultEngine = config.defaults?.engine;
-    if (defaultEngine && !config.engines?.[defaultEngine]) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["defaults", "engine"],
-            message: "engine does not name a configured engine",
-        });
-    }
-    // One rule for every key unattended model work reads its engine from: the
-    // engine must confine the model-work tool policy (an LLM, or an agent whose
-    // harness does), because that work runs over generated content with no one
-    // watching.
-    const confining = [...HARNESS_MODEL_WORK_IDS];
-    const confiningPlatforms = `${confining.slice(0, -1).join(", ")} or ${confining.at(-1)}`;
-    const modelWorkEngine = (name, path) => {
-        if (!name)
-            return;
-        const engine = config.engines?.[name];
-        if (!engine) {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, path, message: "engine does not name a configured engine" });
-        }
-        else if (engine.kind !== "llm" && !HARNESS_MODEL_WORK_IDS.has(engine.platform)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path,
-                message: `engine "${name}" (platform ${engine.platform}) cannot confine the model-work tool policy, which unattended model work requires. Use an LLM engine, or an agent engine on ${confiningPlatforms}.`,
-            });
-        }
-    };
-    modelWorkEngine(config.defaults?.llmEngine, ["defaults", "llmEngine"]);
-    for (const [passName, pass] of Object.entries(config.index ?? {})) {
-        const engine = pass?.engine;
-        if (typeof engine === "string")
-            modelWorkEngine(engine, ["index", passName, "engine"]);
-    }
-    const workflowJudge = config.workflow?.judgeEngine;
-    if (workflowJudge && !config.engines?.[workflowJudge]) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["workflow", "judgeEngine"],
-            message: "judgeEngine does not name a configured engine",
-        });
-    }
-    const defaultStrategy = config.defaults?.improveStrategy;
-    if (defaultStrategy &&
+    const improveStrategy = config.improve?.strategy;
+    if (improveStrategy &&
         // graph-refresh is exempt from this eager, config-load-time check: unlike
         // a plain typo, it is a specific, known retirement, and refusing it here
         // would fail every command's config load (including `akm migrate apply`,
         // the one that fixes this). `resolveImproveStrategy`
         // (src/commands/improve/improve-strategies.ts) refuses it lazily, at
         // improve-invocation time, with the same message either way.
-        defaultStrategy !== "graph-refresh" &&
+        improveStrategy !== "graph-refresh" &&
         // The strategies removed in 0.10 (#1130) are exempt for the same reason:
         // `resolveImproveStrategy` refuses them lazily, naming `default`.
-        !REMOVED_IMPROVE_STRATEGY_NAMES.includes(defaultStrategy) &&
-        !BUILTIN_IMPROVE_STRATEGY_NAMES.includes(defaultStrategy) &&
-        !config.improve?.strategies?.[defaultStrategy]) {
+        !REMOVED_IMPROVE_STRATEGY_NAMES.includes(improveStrategy) &&
+        !BUILTIN_IMPROVE_STRATEGY_NAMES.includes(improveStrategy) &&
+        !config.improve?.strategies?.[improveStrategy]) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            path: ["defaults", "improveStrategy"],
-            message: "improveStrategy does not name a built-in or configured strategy",
+            path: ["improve", "strategy"],
+            message: "strategy does not name a built-in or configured improve strategy",
         });
     }
-    for (const [strategyName, strategy] of Object.entries(config.improve?.strategies ?? {})) {
-        const strategyPath = ["improve", "strategies", strategyName];
-        modelWorkEngine(strategy.engine, [...strategyPath, "engine"]);
-        for (const [processName, process] of Object.entries(strategy.processes ?? {})) {
-            const processConfig = process;
-            const processPath = [...strategyPath, "processes", processName];
-            if (processConfig.engine && !IMPROVE_ENGINE_PROCESSES.includes(processName)) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: [...processPath, "engine"],
-                    message: `${processName} does not dispatch an engine`,
-                });
-            }
-            else {
-                modelWorkEngine(processConfig.engine, [...processPath, "engine"]);
-            }
-            if (processConfig.judgment?.enabled === true) {
-                modelWorkEngine(processConfig.judgment.engine, [...processPath, "judgment", "engine"]);
-            }
-            modelWorkEngine(processConfig.qualityGate?.engine, [...processPath, "qualityGate", "engine"]);
-        }
-    }
     // #464.a: defaultWriteTarget must name a configured source. 0.9.0 (spec
     // §10.1): sources are `bundles` keys, so it must name a bundle. With no
     // bundles configured, error out instead of silently accepting (no implicit

package/dist/core/config/config-sources.js

@@ -117,7 +117,7 @@ function hashBundleSourceIdentity(identity) {
 }
 /**
  * The resolved primary stash path — the `defaultBundle`'s filesystem `path`
- * (spec §10.1) — or `undefined` when no filesystem primary is configured.
+ * — or `undefined` when no filesystem primary is configured.
  */
 export function primaryBundlePath(config) {
     const bundles = config.bundles;
@@ -212,12 +212,12 @@ export function bundleEntryToSourceEntry(key, bundle, isPrimary = false) {
     return undefined;
 }
 /**
- * Desired 0.9.0 bundle descriptor for a registry-installed source (spec §10.1).
+ * Desired 0.9.0 bundle descriptor for a registry-installed source.
  * Maps the install source kind onto the ONE source descriptor a bundle entry
  * carries: git/github → a provider-ready clone URL, npm → `{ npm: ref }`,
  * everything else (local/filesystem) → `{ path: stashRoot }`.
  *
- * CRITICAL (spec §10.2:453): the materialized cache root NEVER appears in the
+ * CRITICAL: the materialized cache root NEVER appears in the
  * descriptor for a git/npm bundle — the desired config carries only the source
  * descriptor; the install locator stays in `registryId` and the resolved root
  * belongs exclusively in the lock's `localRoot`. Callers layer

package/dist/core/config/config-types.js

@@ -3,10 +3,10 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 // Harness ids derive from the harness registry; nothing the registry imports
 // reaches `core/config` at runtime, so there is no cycle.
-import { HARNESS_AGENT_DISPATCH_IDS, VALID_HARNESS_IDS } from "../../integrations/harnesses/index.js";
+import { VALID_HARNESS_IDS } from "../../integrations/harnesses/index.js";
 /**
  * Canonical list of valid agent harness / platform ids, derived from the harness
- * registry so the Zod `AgentPlatformSchema` enum, the agent-engine platform
- * union, and setup's `DetectedHarness` union cannot drift.
+ * registry so the harness `platform` check and setup's `DetectedHarness` union
+ * cannot drift.
  */
-export { HARNESS_AGENT_DISPATCH_IDS, VALID_HARNESS_IDS };
+export { VALID_HARNESS_IDS };