@agentxm/workspace-state 0.29.4 → 0.30.1

package/dist/src/index.d.ts

@@ -67,16 +67,18 @@ export { WorkspaceLocation, type WorkspaceLocationService } from "./workspace/lo
 export { SettingsReader, type SettingsReaderService } from "./workspace/settings-reader.js";
 export { LockfileReader, type LockfileReaderService } from "./workspace/lockfile-reader.js";
 export { readOtherScopeState, type OtherScopeState } from "./workspace/other-scope-reader.js";
-export { DesiredStateReader, type DesiredStateReaderService, } from "./workspace/desired-state-reader.js";
+export { DesiredStateReader, type DesiredStateReaderService, type DesiredStateGraphInputs, } from "./workspace/desired-state-reader.js";
 export { WorkspaceRecords, type WorkspaceRecordsService } from "./workspace/workspace-records.js";
 export { ExtensionPaths, type ExtensionPathsService } from "./workspace/extension-paths-service.js";
 export { SettingsWriter, type SettingsWriterService } from "./workspace/settings-writer.js";
 export { AcceptedResolutionWriter, type AcceptedResolutionWriterService, } from "./workspace/accepted-resolution-writer.js";
 export { DesiredStateWriter, type DeclareArgsByType, type DesiredStateWriterService, } from "./workspace/desired-state-writer.js";
+export { settingsEntries, lockEntries } from "./workspace/entry-accessors.js";
 export type { LockEntriesOf, LockEntryByType, SettingsEntriesOf, SettingsEntryByType, } from "./workspace/entry-accessors.js";
 export { WorkspaceMutations, type WorkspaceMutationsService, type WorkspaceMutationsError, type WorkspaceMutationsOptions, type WorkspaceSettingsReadFailure, type WorkspaceLockfileReadFailure, type WorkspaceStateReadFailure, type WorkspaceSettingsMutationFailure, type WorkspaceLockfileMutationFailure, type WorkspaceStateMutationFailure, type SetSkillArgs, type SetPackArgs, type SetMcpServerArgs, type SetSubagentArgs, type SetRuleArgs, type SetHookArgs, type SetKnowledgeArgs, type PackDirPath, type ExtensionTarget, type ExtensionTargetFor, type LockfileState, type SkillExtensionTarget, type PackExtensionTarget, type McpServerExtensionTarget, type SubagentExtensionTarget, type RuleExtensionTarget, type HookExtensionTarget, type KnowledgeExtensionTarget, } from "./workspace/service-interface.js";
 export { LockfileDecodeError, LockfileIoError, LockfileParseError, LockfileVersionUnsupported, SettingsDecodeError, SettingsIoError, SettingsParseError, SkillDiscoveryRootInvalid, SubagentScanFailed, WorkspaceRootEscape, type LockfileReadError, type SettingsReadError, } from "./workspace/read-model/errors.js";
 export { AcceptedResolutionMissing, CanonicalPathRemovalError, DesiredPackGraphIncomplete, InlineExtensionSourceMissing, InvalidAgentId, LockedSkillMissing, LockEntryEndpointConflict, LockEntryNameInvalid, LockEntrySourceMissing, LockEntrySourceTypeConflict, LockEntryUrlInvalid, PackageContentHashFailed, SettingsEntryMissing, SupersededCanonicalRemovalFailed, SymlinkCreationError, WorkspaceLayoutError, WorkspaceNotInitialized, WorkspaceSourceInvalid, } from "./workspace/errors.js";
 export { setupScopeSupport, setupScopeSupportOutcomes, type SetupScopeSupportCategory, type SetupScopeSupportOutcome, type SetupScopeSupportReasonCode, type SetupScopeSupportStatus, } from "./workspace/setup-scope-support.js";
 export { configuredAgentLifecycleOutcomes, EXTENSION_CONFIGURED_AGENT_POLICY, type ConfiguredAgentLifecycleState, } from "./workspace/configured-agent-outcomes.js";
+export { lockEntrySemanticallyEqual } from "./workspace/accepted-resolution-writer.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -85,6 +85,7 @@ export { ExtensionPaths } from "./workspace/extension-paths-service.js";
 export { SettingsWriter } from "./workspace/settings-writer.js";
 export { AcceptedResolutionWriter, } from "./workspace/accepted-resolution-writer.js";
 export { DesiredStateWriter, } from "./workspace/desired-state-writer.js";
+export { settingsEntries, lockEntries } from "./workspace/entry-accessors.js";
 // TRANSITIONAL workspace mutation facade. No CLI handler composes it any
 // more; the domain packages under packages/core still do, and it is removed
 // when the last of them reads and writes through the narrow services above.
@@ -95,4 +96,5 @@ export { LockfileDecodeError, LockfileIoError, LockfileParseError, LockfileVersi
 export { AcceptedResolutionMissing, CanonicalPathRemovalError, DesiredPackGraphIncomplete, InlineExtensionSourceMissing, InvalidAgentId, LockedSkillMissing, LockEntryEndpointConflict, LockEntryNameInvalid, LockEntrySourceMissing, LockEntrySourceTypeConflict, LockEntryUrlInvalid, PackageContentHashFailed, SettingsEntryMissing, SupersededCanonicalRemovalFailed, SymlinkCreationError, WorkspaceLayoutError, WorkspaceNotInitialized, WorkspaceSourceInvalid, } from "./workspace/errors.js";
 export { setupScopeSupport, setupScopeSupportOutcomes, } from "./workspace/setup-scope-support.js";
 export { configuredAgentLifecycleOutcomes, EXTENSION_CONFIGURED_AGENT_POLICY, } from "./workspace/configured-agent-outcomes.js";
+export { lockEntrySemanticallyEqual } from "./workspace/accepted-resolution-writer.js";
 //# sourceMappingURL=index.js.map

package/dist/src/workspace/accepted-canonical-ref.d.ts

@@ -14,6 +14,8 @@ interface AcceptedCanonicalRefArgs {
     readonly workspace: WorkspaceMutationsService;
     readonly type: DesiredExtensionNode["type"];
     readonly name: string;
+    /** Proposed authority when preparing a transition before publishing intent. */
+    readonly desired?: DesiredExtensionNode;
 }
 /** Every failure the accepted-canonical reconstruction functions can produce. */
 export type AcceptedCanonicalRefError = WorkspaceStateReadFailure | LockEntryToRefError | AcceptedResolutionMissing | InlineExtensionSourceMissing | WorkspaceSourceInvalid | PathTraversalDetected | PackageContentHashFailed;
@@ -50,7 +52,7 @@ export declare const acceptedLockedResolutionRef: (args: AcceptedCanonicalRefArg
  * even when its canonical materialization is absent or divergent.
  */
 export declare const acceptedResolutionRef: (args: AcceptedCanonicalRefArgs) => Effect.Effect<Option.Option<ExtensionRef>, AcceptedCanonicalRefError, FileSystem.FileSystem | Path.Path>;
-export declare const acceptedCanonicalObservation: ({ workspace, type, name, }: AcceptedCanonicalRefArgs) => Effect.Effect<Option.Option<AcceptedCanonicalObservation>, AcceptedCanonicalRefError, FileSystem.FileSystem | Path.Path>;
+export declare const acceptedCanonicalObservation: ({ workspace, type, name, desired: proposed, }: AcceptedCanonicalRefArgs) => Effect.Effect<Option.Option<AcceptedCanonicalObservation>, AcceptedCanonicalRefError, FileSystem.FileSystem | Path.Path>;
 export declare const usableAcceptedCanonicalObservation: (args: AcceptedCanonicalRefArgs) => Effect.Effect<Option.Option<UsableAcceptedCanonicalObservation>, AcceptedCanonicalRefError, FileSystem.FileSystem | Path.Path>;
 export declare const usableAcceptedCanonical: (args: AcceptedCanonicalRefArgs) => Effect.Effect<Option.Option<UsableAcceptedCanonical>, AcceptedCanonicalRefError, FileSystem.FileSystem | Path.Path>;
 export declare const usableAcceptedCanonicalRef: (args: AcceptedCanonicalRefArgs) => Effect.Effect<Option.Option<ExtensionRef>, AcceptedCanonicalRefError, FileSystem.FileSystem | Path.Path>;

package/dist/src/workspace/accepted-canonical-ref.js

@@ -188,16 +188,16 @@ const refForDesired = (workspace, desired) => Effect.gen(function* () {
  * even when its canonical materialization is absent or divergent.
  */
 export const acceptedResolutionRef = (args) => Effect.gen(function* () {
-    const graph = yield* args.workspace.getDesiredStateGraph();
-    const desired = graph.nodes.find((node) => node.type === args.type && node.name === args.name);
+    const desired = args.desired ??
+        (yield* args.workspace.getDesiredStateGraph()).nodes.find((node) => node.type === args.type && node.name === args.name);
     if (desired === undefined || desired.identity.startsWith("workspace:")) {
         return Option.none();
     }
     return yield* acceptedLockedResolutionRef(args);
 });
-export const acceptedCanonicalObservation = ({ workspace, type, name, }) => Effect.gen(function* () {
-    const graph = yield* workspace.getDesiredStateGraph();
-    const desired = graph.nodes.find((node) => node.type === type && node.name === name);
+export const acceptedCanonicalObservation = ({ workspace, type, name, desired: proposed, }) => Effect.gen(function* () {
+    const desired = proposed ??
+        (yield* workspace.getDesiredStateGraph()).nodes.find((node) => node.type === type && node.name === name);
     if (desired === undefined)
         return Option.none();
     const accepted = yield* getAcceptedResolution(workspace, type, name);
@@ -223,7 +223,10 @@ export const usableAcceptedCanonical = (args) => Effect.gen(function* () {
     if (Option.isNone(canonical))
         return Option.none();
     const ref = yield* refForDesired(args.workspace, canonical.value.desired);
-    return Option.some({ ...canonical.value, ref });
+    // A usable local acquisition is the accepted copy, even if the original
+    // directory has changed or disappeared. Keep sourcePath as its identity.
+    const retainedRef = ref.refType === "local" ? { ...ref, location: canonical.value.observation.path } : ref;
+    return Option.some({ ...canonical.value, ref: retainedRef });
 });
 export const usableAcceptedCanonicalRef = (args) => usableAcceptedCanonical(args).pipe(Effect.map(Option.map((canonical) => canonical.ref)));
 //# sourceMappingURL=accepted-canonical-ref.js.map

package/dist/src/workspace/accepted-resolution-writer.js

@@ -37,8 +37,6 @@ export const stableCompare = (left, right) => JSON.stringify(normalizeForStableC
 export const lockEntrySemanticallyEqual = (current, next) => current !== undefined && stableCompare(current, next);
 /** Keep the recorded object when the replacement carries the same facts. */
 export const preserveAcceptedResolutionOnNoop = (current, next) => (lockEntrySemanticallyEqual(current, next) && current !== undefined ? current : next);
-/** Types whose semantically unchanged resolution skips the commit entirely. */
-const skipsUnchangedCommit = (type) => type === "skill" || type === "subagent";
 export const makeAcceptedResolutionWriter = (location, mutex) => {
     const current = readLockfileCell(location, location.runtimeDir);
     const commit = (base, next) => commitLockfileSnapshotUpdateAtPath(location.lockPath, base, next);
@@ -48,7 +46,7 @@ export const makeAcceptedResolutionWriter = (location, mutex) => {
             const lockfile = yield* current;
             const accessor = lockEntries[type];
             const previous = accessor.entries(lockfile)[key];
-            if (skipsUnchangedCommit(type) && lockEntrySemanticallyEqual(previous, entry))
+            if (lockEntrySemanticallyEqual(previous, entry))
                 return;
             yield* commit(lockfile, accessor.set(lockfile, key, preserveAcceptedResolutionOnNoop(previous, entry)));
         })).pipe(Effect.withSpan("AcceptedResolutionWriter.setAccepted")),

package/dist/src/workspace/desired-pack-lock.d.ts

@@ -2,17 +2,18 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import type { Lockfile } from "../lockfile/schema.js";
-import { type DesiredStateGraph } from "./desired-state-graph.js";
+import { type DesiredStateGraph, type ProspectivePackRef } from "./desired-state-graph.js";
 import type { WorkspaceLayout } from "./layout.js";
 interface ValidateDesiredPackLockArgs {
     readonly graph: DesiredStateGraph;
     readonly lockfile: Lockfile;
     readonly layout: WorkspaceLayout;
+    readonly prospectivePacks?: ReadonlyArray<ProspectivePackRef>;
 }
 /**
  * Authorize enabled external Pack manifests against their accepted lock row.
  * Workspace-authored Pack manifests are desired authority and need no lock row.
  */
-export declare const validateDesiredPackLock: ({ graph, lockfile, layout, }: ValidateDesiredPackLockArgs) => Effect.Effect<DesiredStateGraph, never, FileSystem.FileSystem | Path.Path>;
+export declare const validateDesiredPackLock: ({ graph, lockfile, layout, prospectivePacks, }: ValidateDesiredPackLockArgs) => Effect.Effect<DesiredStateGraph, never, FileSystem.FileSystem | Path.Path>;
 export {};
 //# sourceMappingURL=desired-pack-lock.d.ts.map

package/dist/src/workspace/desired-pack-lock.js

@@ -52,7 +52,7 @@ const decodeManifest = Schema.decodeUnknownSync(PackManifestSchema, {
  * Authorize enabled external Pack manifests against their accepted lock row.
  * Workspace-authored Pack manifests are desired authority and need no lock row.
  */
-export const validateDesiredPackLock = ({ graph, lockfile, layout, }) => Effect.gen(function* () {
+export const validateDesiredPackLock = ({ graph, lockfile, layout, prospectivePacks = [], }) => Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const problems = [];
@@ -82,24 +82,25 @@ export const validateDesiredPackLock = ({ graph, lockfile, layout, }) => Effect.
             continue;
         }
         const manifestPath = path.join(computePackPathsForLayout(path.join, layout, entry.sourceName, identity.owner, identity.name).canonicalPath, PACK_MANIFEST_FILENAME);
-        const readResult = yield* Effect.result(fs.readFileString(manifestPath));
-        if (Result.isFailure(readResult)) {
-            problems.push({
-                type: "pack-manifest-content-mismatch",
-                pack: node.identity,
-                path: manifestPath,
-                status: "missing",
-                acceptedVersion: entry.resolvedVersion,
-                acceptedContentIdentity: entry.manifestContentIdentity,
-            });
-            invalidPacks.add(normalizedPackIdentity(node.identity));
-            continue;
-        }
-        const decoded = Result.try({
-            try: () => decodeManifest(JSON.parse(readResult.success)),
-            catch: () => undefined,
-        });
-        const observedManifest = Result.isSuccess(decoded) && decoded.success !== undefined ? decoded.success : undefined;
+        const prospective = prospectivePacks.find((ref) => ref.owner === identity.owner && ref.pack.name === identity.name);
+        const observedManifest = prospective === undefined
+            ? yield* Effect.gen(function* () {
+                const readResult = yield* Effect.result(fs.readFileString(manifestPath));
+                if (Result.isFailure(readResult))
+                    return undefined;
+                const decoded = Result.try({
+                    try: () => decodeManifest(JSON.parse(readResult.success)),
+                    catch: () => undefined,
+                });
+                return Result.isSuccess(decoded) ? decoded.success : undefined;
+            })
+            : {
+                owner: prospective.owner,
+                type: "pack",
+                name: prospective.pack.name,
+                version: prospective.version,
+                dependencies: prospective.pack.dependencies,
+            };
         const observedContentIdentity = observedManifest === undefined
             ? undefined
             : computePackManifestContentIdentity(observedManifest);
@@ -109,7 +110,7 @@ export const validateDesiredPackLock = ({ graph, lockfile, layout, }) => Effect.
                 type: "pack-manifest-content-mismatch",
                 pack: node.identity,
                 path: manifestPath,
-                status: "changed",
+                status: observedManifest === undefined ? "missing" : "changed",
                 acceptedVersion: entry.resolvedVersion,
                 acceptedContentIdentity: entry.manifestContentIdentity,
                 ...(observedManifest === undefined || observedContentIdentity === undefined

package/dist/src/workspace/desired-state-graph.js

@@ -242,6 +242,8 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
         });
         const workspacePack = isWorkspaceSourceLocator(entry.source);
         const configuredRegistrySource = registryLocator(entry.source)?.sourceName ?? "agentxm";
+        if (entry.enabled === false)
+            continue;
         const manifestPath = path.join(layout === undefined
             ? path.join(baseDir, workspacePack
                 ? configuredAuthoredDirectory(settings, "pack")
@@ -308,7 +310,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
                 identity: dependencyIdentity,
                 authority: "sourced",
                 source: `${fqn}@${constraint}`,
-                enabled: entry.enabled !== false,
+                enabled: true,
                 constraint,
                 origin: {
                     type: "pack",
@@ -316,7 +318,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
                     manifestPath: path.relative(baseDir, manifestPath),
                     source: fqn,
                     constraint,
-                    enabled: entry.enabled !== false,
+                    enabled: true,
                 },
             });
         }

package/dist/src/workspace/desired-state-reader.d.ts

@@ -11,15 +11,21 @@ import type * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import type * as Path from "effect/Path";
 import { type DesiredStateGraph, type ProspectivePackRef } from "./desired-state-graph.js";
+import type { Settings } from "../settings/index.js";
+import type { Lockfile } from "../lockfile/index.js";
 import { DesiredPackGraphIncomplete } from "./errors.js";
 import { WorkspaceLocation, type WorkspaceLocationService } from "./location.js";
 import type { ExtensionTarget, WorkspaceStateReadFailure } from "./service-interface.js";
 import { SettingsReader, type SettingsReaderService } from "./settings-reader.js";
+/** Authoritative inputs for evaluating a candidate without publishing it. */
+export interface DesiredStateGraphInputs {
+    readonly settings?: Settings;
+    readonly acceptedResolutions?: Lockfile;
+    readonly prospectivePacks?: ReadonlyArray<ProspectivePackRef>;
+}
 export interface DesiredStateReaderService {
     /** Build desired extension state from settings and installed or prospective Pack manifests. */
-    readonly graph: (options?: {
-        readonly prospectivePacks?: ReadonlyArray<ProspectivePackRef>;
-    }) => Effect.Effect<DesiredStateGraph, WorkspaceStateReadFailure, FileSystem.FileSystem | Path.Path>;
+    readonly graph: (options?: DesiredStateGraphInputs) => Effect.Effect<DesiredStateGraph, WorkspaceStateReadFailure, FileSystem.FileSystem | Path.Path>;
     /** Whether an installed Pack's dependency maps reference the target. */
     readonly isRequiredByInstalledPack: (target: ExtensionTarget) => Effect.Effect<boolean, WorkspaceStateReadFailure | DesiredPackGraphIncomplete, FileSystem.FileSystem | Path.Path>;
 }

package/dist/src/workspace/desired-state-reader.js

@@ -19,7 +19,7 @@ export class DesiredStateReader extends ServiceMap.Service()("@agentxm/workspace
 }
 export const makeDesiredStateReader = (location, settings) => {
     const graph = (options) => Effect.gen(function* () {
-        const current = yield* settings.settings;
+        const current = options?.settings ?? (yield* settings.settings);
         const configuredSources = yield* settings.configuredSources;
         const layout = yield* Ref.get(location.layout);
         const registryAuthorities = Object.fromEntries(configuredSources.flatMap((source) => source.type === "registry" ? [[source.name, source.location]] : []));
@@ -32,8 +32,15 @@ export const makeDesiredStateReader = (location, settings) => {
                 ? {}
                 : { prospectivePacks: options.prospectivePacks }),
         });
-        const lockfile = yield* readLockfileCell(location, location.runtimeDir);
-        return yield* validateDesiredPackLock({ graph: built, lockfile, layout });
+        const lockfile = options?.acceptedResolutions ?? (yield* readLockfileCell(location, location.runtimeDir));
+        return yield* validateDesiredPackLock({
+            graph: built,
+            lockfile,
+            layout,
+            ...(options?.prospectivePacks === undefined
+                ? {}
+                : { prospectivePacks: options.prospectivePacks }),
+        });
     }).pipe(Effect.withSpan("DesiredStateReader.graph"));
     return {
         graph,

package/dist/src/workspace/service-interface.d.ts

@@ -28,7 +28,8 @@ import type { ReadModelRecordRow } from "./read-model-record-types.js";
 import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
 import type { ExtensionInventory } from "./read-model/extensions/inventory.js";
 import type { ResolvedKnowledgeDiscoveryConfig } from "../knowledge/discovery-config.js";
-import type { DesiredStateGraph, ProspectivePackRef } from "./desired-state-graph.js";
+import type { DesiredStateGraphInputs } from "./desired-state-reader.js";
+import type { DesiredStateGraph } from "./desired-state-graph.js";
 import type { AbsolutePath } from "@agentxm/extension-model/unstable/path-types";
 import type { WorkspaceLayout } from "./layout.js";
 import type { ExtensionPathSource } from "./extension-paths.js";
@@ -211,9 +212,7 @@ export interface WorkspaceMutationsService {
     /** Probe lockfile state for policy decisions: ok | missing | invalid. */
     readonly getLockfileState: () => Effect.Effect<LockfileState, LockfileValidationError | WorkspaceRootEscape>;
     /** Build desired extension state from settings and installed or prospective Pack manifests. */
-    readonly getDesiredStateGraph: (options?: {
-        readonly prospectivePacks?: ReadonlyArray<ProspectivePackRef>;
-    }) => Effect.Effect<DesiredStateGraph, WorkspaceStateReadFailure>;
+    readonly getDesiredStateGraph: (options?: DesiredStateGraphInputs) => Effect.Effect<DesiredStateGraph, WorkspaceStateReadFailure>;
     /** Merged sources from project, user-scope, and built-in defaults. Cached per workspace lifetime. */
     readonly getConfiguredSources: () => Effect.Effect<ReadonlyArray<SourceHostConfig>, WorkspaceSettingsReadFailure>;
     /** Lookup a source by name from the merged sources list. */

package/package.json

@@ -4,20 +4,20 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/agent-integration": "^0.29.4",
-    "@agentxm/extension-content": "^0.29.4",
-    "@agentxm/extension-model": "^0.29.4",
-    "@agentxm/registry-protocol": "^0.29.4",
-    "@agentxm/workspace-transactions": "^0.29.4",
+    "@agentxm/agent-integration": "^0.30.1",
+    "@agentxm/extension-content": "^0.30.1",
+    "@agentxm/extension-model": "^0.30.1",
+    "@agentxm/registry-protocol": "^0.30.1",
+    "@agentxm/workspace-transactions": "^0.30.1",
     "effect": "4.0.0-rc.115",
     "jsonc-parser": "^3.3.1",
     "semver": "^7.8.5",
-    "smol-toml": "1.6.1",
+    "smol-toml": "^1.7.1",
     "yaml": "^2.9.0"
   },
   "description": "AXM workspace state kernel: settings, lockfile, read model, and desired-state vocabulary for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
-    "@agentxm/specification-metadata": "^0.29.4",
+    "@agentxm/specification-metadata": "^0.30.1",
     "@effect/platform-node": "4.0.0-rc.115",
     "@effect/vitest": "4.0.0-rc.115",
     "@fast-check/vitest": "^0.5.0",
@@ -31,19 +31,16 @@
   },
   "exports": {
     ".": {
-      "axm-source": "./src/index.ts",
-      "default": "./dist/src/index.js",
-      "types": "./dist/src/index.d.ts"
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
     },
     "./live": {
-      "axm-source": "./src/live.ts",
-      "default": "./dist/src/live.js",
-      "types": "./dist/src/live.d.ts"
+      "types": "./dist/src/live.d.ts",
+      "default": "./dist/src/live.js"
     },
     "./testing": {
-      "axm-source": "./src/testing.ts",
-      "default": "./dist/src/testing.js",
-      "types": "./dist/src/testing.d.ts"
+      "types": "./dist/src/testing.d.ts",
+      "default": "./dist/src/testing.js"
     }
   },
   "files": [
@@ -66,5 +63,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.29.4"
+  "version": "0.30.1"
 }