@agentxm/workspace-lint 0.28.12 → 0.28.13

package/dist/src/testing.js

@@ -0,0 +1,303 @@
+/**
+ * @agentxm/workspace-lint deterministic test fixtures.
+ *
+ * A lint run reads a real workspace through the state, agent-repository and
+ * invariant-fact services, so a fixture here composes those over a throwaway
+ * directory rather than answering for them. What it does supply is the two
+ * things a lint example cannot state for itself without becoming brittle: a
+ * configured rule set in which exactly one catalog rule is live, so no
+ * unrelated finding can decide the scenario, and a workspace whose files are
+ * written as the product writes them.
+ *
+ * `ProjectionParticipants` stays in the layer's requirements on purpose. Which
+ * extension types contribute projections is a fact this package may not
+ * invent — `@agentxm/workspace-lint` does not depend on the materialization
+ * managers — so the caller states it, either with the real registry from
+ * `@agentxm/extension-materialization/live` or with a deliberate stand-in from
+ * `@agentxm/workspace-projection/testing`.
+ *
+ * Production source never imports this module.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as nodePath from "node:path";
+import * as Layer from "effect/Layer";
+import { decodeAbsolutePathSync } from "@agentxm/extension-model/unstable/path-types";
+import { AXM_SKILL_CLI_VERSION_METADATA_KEY, AXM_SKILL_CLI_VERSION_RANGE_METADATA_KEY, } from "@agentxm/extension-resolution";
+import { AxmSkillCompatibilityPolicyTest } from "@agentxm/extension-resolution/testing";
+import { CodingAgentRepositoryLive, NativeWriteAuthorityLive, WorkspaceInvariantFactsLive, } from "@agentxm/workspace-projection/live";
+import { WorkspaceStateLive } from "@agentxm/workspace-state/live";
+import { ConfiguredAgentOutcomesProviderTest } from "@agentxm/workspace-state/testing";
+import { allCatalogRuleIds } from "./catalog/index.js";
+/**
+ * A rule configuration in which exactly one catalog rule is live and every
+ * other is `off`. A lint example that asserts on one rule's finding needs
+ * this: without it an unrelated rule's finding can decide the run's exit
+ * category and the example proves nothing about its own subject.
+ *
+ * Pass `undefined` for `severity` to leave the named rule at its catalog
+ * default while every other rule is silenced. An unknown rule id throws, so a
+ * renamed rule fails the example rather than silently matching nothing.
+ */
+export const isolatedLintRules = (ruleId, severity) => {
+    if (!allCatalogRuleIds.includes(ruleId)) {
+        throw new Error(`Unknown lint rule '${ruleId}'`);
+    }
+    const rules = {};
+    for (const id of allCatalogRuleIds) {
+        if (id !== ruleId)
+            rules[id] = "off";
+    }
+    if (severity !== undefined)
+        rules[ruleId] = severity;
+    return rules;
+};
+/**
+ * Every workspace-facing service a lint run over one root reads through. A
+ * Git-index run lints a materialized snapshot rather than the working tree, so
+ * the root a run's services are built over is decided by the admitted
+ * selection, not by the directory a fixture created.
+ */
+export const lintWorkspaceServices = (args) => {
+    const state = WorkspaceStateLive({
+        scope: "project",
+        projectRoot: decodeAbsolutePathSync(args.workspaceRoot),
+    });
+    const agents = Layer.provideMerge(Layer.mergeAll(CodingAgentRepositoryLive, ConfiguredAgentOutcomesProviderTest), state);
+    return Layer.provideMerge(Layer.mergeAll(WorkspaceInvariantFactsLive.pipe(Layer.provide(NativeWriteAuthorityLive)), AxmSkillCompatibilityPolicyTest(args.cliVersion ?? null)), agents);
+};
+/** A throwaway initialized workspace with the services a lint run reads it through. */
+export const makeLintWorkspace = (options = {}) => {
+    const root = fs.realpathSync(fs.mkdtempSync(nodePath.join(os.tmpdir(), "axm-lint-")));
+    const absolute = (relativePath) => nodePath.join(root, relativePath);
+    const writeFile = (relativePath, contents) => {
+        const file = absolute(relativePath);
+        fs.mkdirSync(nodePath.dirname(file), { recursive: true });
+        fs.writeFileSync(file, contents);
+    };
+    const writeSettings = (settings) => {
+        writeFile("axm.json", `${JSON.stringify({ agents: [], ...settings }, null, 2)}\n`);
+    };
+    writeSettings(options.settings ?? {});
+    for (const [relativePath, contents] of Object.entries(options.files ?? {})) {
+        writeFile(relativePath, contents);
+    }
+    const link = (linkPath, targetPath) => {
+        const linkFile = absolute(linkPath);
+        fs.mkdirSync(nodePath.dirname(linkFile), { recursive: true });
+        fs.symlinkSync(nodePath.relative(nodePath.dirname(linkFile), absolute(targetPath)), linkFile, "dir");
+    };
+    const snapshot = () => {
+        const entries = [];
+        const walk = (directory) => {
+            for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+                const child = nodePath.join(directory, entry.name);
+                const relative = nodePath.relative(root, child);
+                if (entry.isSymbolicLink()) {
+                    entries.push([relative, `symlink:${fs.readlinkSync(child)}`]);
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    entries.push([relative, "directory"]);
+                    walk(child);
+                    continue;
+                }
+                entries.push([relative, fs.readFileSync(child, "utf8")]);
+            }
+        };
+        walk(root);
+        return entries.sort((left, right) => left[0].localeCompare(right[0]));
+    };
+    const layer = lintWorkspaceServices({
+        workspaceRoot: root,
+        cliVersion: options.cliVersion ?? null,
+    });
+    return {
+        root,
+        writeFile,
+        readFile: (relativePath) => fs.readFileSync(absolute(relativePath), "utf8"),
+        exists: (relativePath) => fs.existsSync(absolute(relativePath)),
+        remove: (relativePath) => fs.rmSync(absolute(relativePath), { force: true, recursive: true }),
+        writeSettings,
+        link,
+        snapshot,
+        layer,
+        cleanup: () => fs.rmSync(root, { recursive: true, force: true }),
+    };
+};
+// -----------------------------------------------------------------------------
+// The official AXM skill
+// -----------------------------------------------------------------------------
+/** Where a project workspace keeps the official AXM skill's canonical package. */
+export const OFFICIAL_AXM_SKILL_PACKAGE_ROOT = "agent_extensions/agentxm/@agentxm/skills/axm";
+/** Where a workspace that authors its own `axm` skill keeps it. */
+export const AUTHORED_AXM_SKILL_PACKAGE_ROOT = "skills/axm";
+/** The agent directory entry `claude-code` reads a project skill from. */
+export const CLAUDE_CODE_SKILLS_DIR = ".claude/skills";
+/** The two rules that decide what lint says about the official AXM skill. */
+export const OFFICIAL_AXM_SKILL_RULE_IDS = [
+    "workspace/axm-skill-declared",
+    "workspace/axm-skill-compatible",
+];
+/**
+ * A rule configuration in which only the two official-skill rules are live.
+ * An official-skill example is about what lint concludes from the declaration
+ * and the installed package, so no unrelated rule may decide its run.
+ */
+export const isolateOfficialAxmSkillRules = () => {
+    const live = new Set(OFFICIAL_AXM_SKILL_RULE_IDS);
+    const rules = {};
+    for (const id of allCatalogRuleIds) {
+        if (!live.has(id))
+            rules[id] = "off";
+    }
+    return rules;
+};
+/** The CLI release every official-skill fixture but the prerelease one runs as. */
+export const FIXTURE_CLI_VERSION = "1.2.3";
+/** The prerelease CLI release the in-range prerelease fixture runs as. */
+export const FIXTURE_PRERELEASE_CLI_VERSION = "1.3.0-preview.1";
+/** The bounded, wildcard-free range the fixture skills declare. */
+const FIXTURE_CLI_VERSION_RANGE = ">=1.0.0 <2.0.0";
+const officialSkillManifest = (version) => `${JSON.stringify({
+    $schema: "https://axm.sh/schemas/skill.schema.json",
+    owner: "@agentxm",
+    type: "skill",
+    name: "axm",
+    version,
+    description: "The official AXM skill.",
+}, null, 2)}\n`;
+const officialSkillMd = (metadata) => [
+    "---",
+    "name: axm",
+    "description: The official AXM skill.",
+    ...(metadata === null
+        ? []
+        : [
+            "metadata:",
+            `  ${AXM_SKILL_CLI_VERSION_METADATA_KEY}: "${metadata.cliVersion}"`,
+            `  ${AXM_SKILL_CLI_VERSION_RANGE_METADATA_KEY}: "${metadata.cliVersionRange}"`,
+        ]),
+    "---",
+    "",
+    "# axm",
+    "",
+    "Operate AXM from the agent.",
+    "",
+].join("\n");
+/** The canonical package files a materialized official AXM skill is made of. */
+export const officialAxmSkillPackage = (args) => ({
+    [`${args.packageRoot}/skill.json`]: officialSkillManifest(args.version),
+    ...(args.withSkillMd === false
+        ? {}
+        : { [`${args.packageRoot}/src/SKILL.md`]: officialSkillMd(args.metadata) }),
+});
+const BUNDLED_ENTRY = { source: "workspace", enabled: true, origin: "bundled" };
+const REGISTRY_SOURCE = "agentxm:@agentxm/skills/axm";
+const bundled = (version, metadataVersion) => ({
+    cliVersion: FIXTURE_CLI_VERSION,
+    skills: { axm: BUNDLED_ENTRY },
+    files: officialAxmSkillPackage({
+        packageRoot: OFFICIAL_AXM_SKILL_PACKAGE_ROOT,
+        version,
+        metadata: { cliVersion: metadataVersion, cliVersionRange: FIXTURE_CLI_VERSION_RANGE },
+    }),
+    realized: [[`${CLAUDE_CODE_SKILLS_DIR}/axm`, `${OFFICIAL_AXM_SKILL_PACKAGE_ROOT}/src`]],
+});
+const arrangeOfficialSkill = (state) => {
+    switch (state) {
+        case "undeclared":
+            return { cliVersion: FIXTURE_CLI_VERSION, files: {}, realized: [] };
+        case "non-official":
+            // Declared under another owner's name: the workspace never asked for the
+            // official skill, so lint has nothing to hold to compatibility.
+            return {
+                cliVersion: FIXTURE_CLI_VERSION,
+                skills: { axm: "@acme/skills/axm" },
+                files: {},
+                realized: [],
+            };
+        case "official-missing":
+            return {
+                cliVersion: FIXTURE_CLI_VERSION,
+                skills: { axm: REGISTRY_SOURCE },
+                files: {},
+                realized: [],
+            };
+        case "official-registry":
+            return {
+                cliVersion: FIXTURE_CLI_VERSION,
+                skills: { axm: REGISTRY_SOURCE },
+                files: officialAxmSkillPackage({
+                    packageRoot: OFFICIAL_AXM_SKILL_PACKAGE_ROOT,
+                    version: "0.0.1",
+                    metadata: { cliVersion: "0.0.1", cliVersionRange: ">=0.0.1 <0.1.0" },
+                }),
+                realized: [[`${CLAUDE_CODE_SKILLS_DIR}/axm`, `${OFFICIAL_AXM_SKILL_PACKAGE_ROOT}/src`]],
+            };
+        case "official-skewed":
+            // The materialized release and the release its compatibility metadata
+            // claims disagree, so nothing about the pair can be trusted.
+            return bundled("0.0.1", FIXTURE_CLI_VERSION);
+        case "official-authored":
+            // A workspace that authors its own `axm` skill publishes under its own
+            // handle, so the settings declare the owner authored content resolves
+            // against.
+            return {
+                cliVersion: FIXTURE_CLI_VERSION,
+                skills: { axm: "workspace" },
+                owner: "@agentxm",
+                files: officialAxmSkillPackage({
+                    packageRoot: AUTHORED_AXM_SKILL_PACKAGE_ROOT,
+                    version: "0.0.1",
+                    metadata: null,
+                }),
+                realized: [[`${CLAUDE_CODE_SKILLS_DIR}/axm`, `${AUTHORED_AXM_SKILL_PACKAGE_ROOT}/src`]],
+            };
+        case "official-compatible":
+            return bundled(FIXTURE_CLI_VERSION, FIXTURE_CLI_VERSION);
+        case "official-compatible-prerelease":
+            return {
+                ...bundled(FIXTURE_PRERELEASE_CLI_VERSION, FIXTURE_PRERELEASE_CLI_VERSION),
+                cliVersion: FIXTURE_PRERELEASE_CLI_VERSION,
+            };
+        case "official-unreadable":
+            return {
+                cliVersion: FIXTURE_CLI_VERSION,
+                skills: { axm: BUNDLED_ENTRY },
+                files: officialAxmSkillPackage({
+                    packageRoot: OFFICIAL_AXM_SKILL_PACKAGE_ROOT,
+                    version: FIXTURE_CLI_VERSION,
+                    metadata: null,
+                    withSkillMd: false,
+                }),
+                realized: [],
+            };
+    }
+};
+/**
+ * A throwaway workspace whose official AXM skill is arranged in the named
+ * state, with the compatibility policy pinned to the CLI release that state
+ * is about.
+ */
+export const makeOfficialAxmSkillWorkspace = (state, options = {}) => {
+    const arrangement = arrangeOfficialSkill(state);
+    const fixture = makeLintWorkspace({
+        settings: {
+            agents: options.agents ?? ["claude-code"],
+            ...(arrangement.owner === undefined ? {} : { owner: arrangement.owner }),
+            ...(arrangement.skills === undefined ? {} : { skills: arrangement.skills }),
+            ...options.settings,
+        },
+        files: { ...arrangement.files, ...options.files },
+        cliVersion: arrangement.cliVersion,
+    });
+    for (const [linkPath, targetPath] of arrangement.realized) {
+        fixture.link(linkPath, targetPath);
+    }
+    return { ...fixture, cliVersion: arrangement.cliVersion };
+};
+//# sourceMappingURL=testing.js.map

package/dist/src/workspace-context.d.ts

@@ -12,12 +12,13 @@ import type * as Effect from "effect/Effect";
 import type * as Option from "effect/Option";
 import type { ExtensionType } from "@agentxm/extension-model/unstable/extensions/common";
 import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
-import type { PackDependencyReachability, AgentOutputInventory, AxmSkillCompatibility, WorkspaceOwnershipIssue, InstructionProjectionSnapshot } from "@agentxm/extension-workspace";
-import type { ProjectionInvariantFact } from "@agentxm/extension-workspace";
+import type { PackDependencyReachability, AgentOutputInventory, WorkspaceOwnershipIssue, InstructionProjectionSnapshot } from "@agentxm/workspace-projection";
+import type { ProjectionInvariantFact } from "@agentxm/workspace-projection";
 import type { CanonicalObservation } from "@agentxm/workspace-state";
 import type { DesiredExtensionNode, DesiredStateGraph } from "@agentxm/workspace-state";
 import type { LockfileReadError, SettingsReadError } from "@agentxm/workspace-state";
 import type { WorkspaceReadModel } from "@agentxm/workspace-state";
+import { type AxmSkillCompatibility } from "@agentxm/extension-resolution";
 /**
  * Context passed to `workspace/*` rules.
  *

package/dist/src/workspace-context.js

@@ -8,5 +8,5 @@
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
-export {};
+import {} from "@agentxm/extension-resolution";
 //# sourceMappingURL=workspace-context.js.map

package/package.json

@@ -4,17 +4,19 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/extension-model": "^0.28.12",
-    "@agentxm/extension-sources": "^0.28.12",
-    "@agentxm/extension-workspace": "^0.28.12",
-    "@agentxm/registry-protocol": "^0.28.12",
-    "@agentxm/workspace-operations": "^0.28.12",
-    "@agentxm/workspace-state": "^0.28.12",
+    "@agentxm/agent-integration": "^0.28.13",
+    "@agentxm/extension-content": "^0.28.13",
+    "@agentxm/extension-model": "^0.28.13",
+    "@agentxm/extension-resolution": "^0.28.13",
+    "@agentxm/extension-sources": "^0.28.13",
+    "@agentxm/workspace-operations": "^0.28.13",
+    "@agentxm/workspace-projection": "^0.28.13",
+    "@agentxm/workspace-state": "^0.28.13",
     "effect": "4.0.0-rc.112"
   },
   "description": "AXM workspace-lint feature: workspace facts, lint rules, findings, normalization, and bounded fix planning for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
-    "@agentxm/agent-integration": "^0.28.12",
+    "@agentxm/agent-integration": "^0.28.13",
     "@effect/platform-node": "4.0.0-rc.112",
     "@effect/vitest": "4.0.0-rc.112",
     "@types/bun": "^1.3.14",
@@ -30,6 +32,11 @@
       "axm-source": "./src/index.ts",
       "default": "./dist/src/index.js",
       "types": "./dist/src/index.d.ts"
+    },
+    "./testing": {
+      "axm-source": "./src/testing.ts",
+      "default": "./dist/src/testing.js",
+      "types": "./dist/src/testing.d.ts"
     }
   },
   "files": [
@@ -46,11 +53,11 @@
     "access": "public"
   },
   "repository": {
-    "directory": "packages/workspace-lint",
+    "directory": "packages/core/workspace-lint",
     "type": "git",
     "url": "https://github.com/agentxm/axm.git"
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.28.12"
-}
+  "version": "0.28.13"
+}

package/dist/src/catalog/workspace-fixtures/fixture-state.d.ts

@@ -1,8 +0,0 @@
-import type { FixtureSpec, ScopeFiles } from "@agentxm/workspace-state";
-import type { WorkspaceState } from "./interpret-ops.js";
-export declare const scopeFilesFromWorkspaceState: (state: WorkspaceState) => ScopeFiles;
-export declare const fixtureSpecFromWorkspaceState: (state: WorkspaceState, scope: "project" | "user", roots: {
-    readonly workspaceRoot: string;
-    readonly userHome: string;
-}) => FixtureSpec;
-//# sourceMappingURL=fixture-state.d.ts.map

package/dist/src/catalog/workspace-fixtures/fixture-state.js

@@ -1,120 +0,0 @@
-import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
-const pathSegments = (relativePath) => relativePath.split("/").filter((segment) => segment.length > 0);
-const firstPathSegment = (relativePath) => pathSegments(relativePath)[0];
-const agentRootForSkillsDir = (skillsDir) => firstPathSegment(skillsDir);
-const relativeUnderAgentRoot = (agentRoot, relativePath) => {
-    if (relativePath === agentRoot)
-        return "";
-    const prefix = `${agentRoot}/`;
-    if (!relativePath.startsWith(prefix))
-        return undefined;
-    return relativePath.slice(prefix.length);
-};
-const skillNameFromPath = (skillsDir, relativePath) => {
-    const prefix = `${skillsDir}/`;
-    if (!relativePath.startsWith(prefix))
-        return undefined;
-    const afterSkillsDir = relativePath.slice(prefix.length);
-    return firstPathSegment(afterSkillsDir);
-};
-const literalFileFor = (relativePath) => {
-    const segments = pathSegments(relativePath);
-    const name = segments.at(-2) ?? segments.at(-1) ?? "fixture";
-    const lower = relativePath.toLowerCase();
-    if (lower.endsWith(".md"))
-        return `# ${name}\n`;
-    if (lower.endsWith(".json"))
-        return "{}\n";
-    if (lower.endsWith(".yaml") || lower.endsWith(".yml"))
-        return "{}\n";
-    return "";
-};
-const addTreeFile = (tree, relativePath, contents = literalFileFor(relativePath)) => {
-    tree[relativePath] = contents;
-};
-const addAgentSkillArtifact = (agentDirs, agentId, relativePath) => {
-    const agent = AGENTS[agentId];
-    const skills = agent.skills;
-    if (skills === undefined)
-        return;
-    const agentRoot = agentRootForSkillsDir(skills.dir);
-    if (agentRoot === undefined)
-        return;
-    const relative = relativeUnderAgentRoot(agentRoot, relativePath);
-    if (relative === undefined)
-        return;
-    const skillName = skillNameFromPath(skills.dir, relativePath);
-    const materializedPath = skillName === undefined
-        ? relative
-        : `${skills.dir.slice(agentRoot.length + 1)}/${skillName}/SKILL.md`;
-    if (materializedPath.length === 0)
-        return;
-    const tree = agentDirs[agentId] ?? {};
-    agentDirs[agentId] = tree;
-    addTreeFile(tree, materializedPath);
-};
-const isKnownAgentId = (id) => Object.hasOwn(AGENTS, id);
-const fileSpecFor = (raw) => {
-    if (raw === undefined)
-        return undefined;
-    if (typeof raw !== "object" || raw === null) {
-        throw new Error(`Fixture state expected an object for settings/lockfile; got ${typeof raw}`);
-    }
-    return { _tag: "valid", contents: raw };
-};
-export const scopeFilesFromWorkspaceState = (state) => {
-    const axmExtensions = {};
-    const agentDirs = {};
-    const agentSettings = {};
-    const agents = Object.values(AGENTS);
-    const addExistingPath = (relativePath) => {
-        const acquiredPrefix = "agent_extensions/";
-        if (relativePath.startsWith(acquiredPrefix)) {
-            addTreeFile(axmExtensions, relativePath.slice(acquiredPrefix.length));
-            return;
-        }
-        const axmPrefix = "agent_extensions/";
-        if (relativePath.startsWith(axmPrefix)) {
-            addTreeFile(axmExtensions, relativePath.slice(axmPrefix.length));
-            return;
-        }
-        for (const agent of agents) {
-            if (agent.skills !== undefined &&
-                skillNameFromPath(agent.skills.dir, relativePath) !== undefined) {
-                addAgentSkillArtifact(agentDirs, agent.id, relativePath);
-            }
-        }
-    };
-    for (const relativePath of state.existingPaths) {
-        addExistingPath(relativePath);
-    }
-    for (const [dir, entries] of state.listings) {
-        for (const entry of entries) {
-            addExistingPath(`${dir}/${entry}`);
-        }
-    }
-    for (const agentId of state.detectedProjectAgents) {
-        if (isKnownAgentId(agentId)) {
-            agentSettings[agentId] = { _tag: "valid", contents: {} };
-        }
-    }
-    const settings = fileSpecFor(state.settings);
-    const lockfile = fileSpecFor(state.lockfile);
-    return {
-        ...(settings === undefined ? {} : { settings }),
-        ...(lockfile === undefined ? {} : { lockfile }),
-        ...(Object.keys(axmExtensions).length === 0 ? {} : { axmExtensions }),
-        ...(Object.keys(agentDirs).length === 0 ? {} : { agentDirs }),
-        ...(Object.keys(agentSettings).length === 0 ? {} : { agentSettings }),
-    };
-};
-export const fixtureSpecFromWorkspaceState = (state, scope, roots) => {
-    const scopeFiles = scopeFilesFromWorkspaceState(state);
-    return {
-        workspaceRoot: roots.workspaceRoot,
-        userHome: roots.userHome,
-        ...(scope === "project" ? { project: scopeFiles } : {}),
-        ...(scope === "user" ? { user: scopeFiles } : {}),
-    };
-};
-//# sourceMappingURL=fixture-state.js.map

package/dist/src/catalog/workspace-fixtures/interpret-ops.d.ts

@@ -1,11 +0,0 @@
-/** Mutable workspace-state fixture shared by read-only lint rule tests. */
-export interface WorkspaceState {
-    settings: unknown;
-    lockfile: unknown;
-    readonly existingPaths: Set<string>;
-    readonly writablePaths: Set<string>;
-    readonly listings: Map<string, Array<string>>;
-    readonly detectedProjectAgents: Set<string>;
-}
-export declare const emptyWorkspaceState: () => WorkspaceState;
-//# sourceMappingURL=interpret-ops.d.ts.map

package/dist/src/catalog/workspace-fixtures/interpret-ops.js

@@ -1,9 +0,0 @@
-export const emptyWorkspaceState = () => ({
-    settings: undefined,
-    lockfile: undefined,
-    existingPaths: new Set(),
-    writablePaths: new Set(),
-    listings: new Map(),
-    detectedProjectAgents: new Set(),
-});
-//# sourceMappingURL=interpret-ops.js.map