@aefree/pi-plastic 0.5.7 → 0.5.8

package/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project follows semantic versioning for public package releases.
 
 ## Unreleased
 
+## [0.5.8] - 2026-09-15
+
+### Fixed
+
+- Resolve pending-diff workspace containment and Xlink ownership by filesystem identity when a workspace is accessed through a real filesystem alias, while retaining the caller's lexical path for Plastic commands and displayed paths. Missing deleted or moved ownership ancestors still fail closed.
+- Retry only npm registry E404 availability checks for a bounded period after trusted publishing; a mismatched, malformed, or unauthorized release identity still fails immediately.
+
 ## [0.5.7] - 2026-09-14
 
 ### Fixed

package/README.md

@@ -75,6 +75,7 @@ The Bash guards run only in Pi processes that actually load this package. A proj
 - `plastic_branchCreate` supports an explicit parent branch independent of the loaded workspace branch, defaults relative names to the current branch when no parent is supplied, and rejects top-level paths unless `allowRootBranch=true` is explicit.
 - `plastic_diff` remains a disabled alias by design. Use `plastic_status` for changed-path listing; do not diff as routine post-edit validation or checkin preflight. When change-boundary evidence is needed, use `plastic_diffFile` for one exact file, `plastic_workspaceDiff` with selected paths or explicit `allPending=true`, or `plastic_diffRevisions` for an explicit historical pair. Diff responses use small defaults and caller-controlled `maxChars` bounds. Automatic pending-file bases bind each status revision ID to its owning workspace or Xlink repository/server, including mixed-Xlink reviews. If ownership cannot be resolved, that comparison is reported unavailable rather than retrieving a bare revision from the caller repository. Historical and workspace bytes are copied to ASCII-safe package-owned paths before the backend runs, while normalized headers retain the logical Unicode labels.
 - `plastic_status(machineReadable=true, format="json")` returns parsed `items`, aggregate `summary`, and `itemCount` (`total`, `returned`, `omitted`) rather than requiring agents to parse Plastic rows. It returns at most 100 items by default; set `maxItems` (up to 500) when more are intentional. `includeRaw=true` adds the original unbounded Plastic output for diagnostics, so omit it for normal agent use to conserve context tokens.
+- Pending-diff ownership containment uses filesystem identity, so a workspace reached through a symlink, junction, or platform filesystem alias still resolves its workspace and nested Xlink bases safely. Plastic commands and returned labels retain the caller's original lexical path; missing deleted or moved ownership ancestors remain unavailable rather than falling back to a parent repository.
 - Preflight is not routine confirmation. Use it for ambiguous or broad mutation scope, moved/deleted path rewriting, compound operations, or explicit preview requests; otherwise rely on exact targets and the tools' runtime guards.
 - `plastic_patch` generates review patches with `cm patch`, including `clean` and `integration` filters for branch review workflows. It does not expose patch apply. Unqualified `br:/...` selectors are qualified only with the current workspace selector's exact repository; otherwise pass `br:/<branch>@<repository>@<server>`.
 - Bash safety rails block `cm diff` and unsafe interactive `cm merge --merge` usage.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aefree/pi-plastic",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "type": "module",
   "engines": {
     "node": ">=22.19.0"

package/src/plastic-core.ts

@@ -406,6 +406,37 @@ const findCanonicalExistingAncestor = (absolutePath: string): string | null =>
     }
 };
 
+const toFilesystemIdentityPath = async (absolutePath: string): Promise<string> =>
+{
+    let candidate = absolutePath;
+    const missingSegments: string[] = [];
+    while (true)
+    {
+        try
+        {
+            const canonicalAncestor = (await fs.realpath(candidate)).replace(/\\/g, "/");
+            return missingSegments.reduce((identityPath, segment) => join(identityPath, segment), canonicalAncestor).replace(/\\/g, "/");
+        }
+        catch (error)
+        {
+            const code = (error as NodeJS.ErrnoException).code;
+            if (code !== "ENOENT" && code !== "ENOTDIR")
+            {
+                throw error;
+            }
+
+            const parent = dirname(candidate);
+            if (parent === candidate)
+            {
+                throw error;
+            }
+
+            missingSegments.unshift(basename(candidate));
+            candidate = parent;
+        }
+    }
+};
+
 const toggleFirstAsciiLetterCase = (value: string): string | null =>
 {
     const index = value.search(/[A-Za-z]/);
@@ -1814,9 +1845,10 @@ const createPendingBaseIdentityResolver = (cwd: string, workdir?: string): Pendi
         });
         return workspaceRepository;
     };
-    const getXlinkRepository = (candidate: string): Promise<RepositoryIdentity | null> =>
+    const getXlinkRepository = async (candidate: string): Promise<RepositoryIdentity | null> =>
     {
-        const key = toPathComparisonKeyFromAbsolutePath(candidate);
+        // Use the physical identity for cache keys, but keep candidate lexical for cm.
+        const key = toPathComparisonKeyFromAbsolutePath(await toFilesystemIdentityPath(candidate));
         let lookup = xlinkLookups.get(key);
         if (!lookup)
         {
@@ -1851,15 +1883,22 @@ const createPendingBaseIdentityResolver = (cwd: string, workdir?: string): Pendi
                 throw new Error(`Plastic status did not provide a base revision ID for '${item.workspacePath}'.`);
             }
             const root = await getWorkspaceRoot();
+            const rootIdentity = await toFilesystemIdentityPath(root);
             const ownershipPath = item.kind === "moved" && item.sourceWorkspacePath
                 ? toNormalizedAbsolutePath(item.sourceWorkspacePath, cwd)
                 : item.normalizedPath;
-            if (!isWithinPathScope(toPathComparisonKeyFromAbsolutePath(ownershipPath), toPathComparisonKeyFromAbsolutePath(root)))
+            if (!isWithinPathScope(
+                toPathComparisonKeyFromAbsolutePath(await toFilesystemIdentityPath(ownershipPath)),
+                toPathComparisonKeyFromAbsolutePath(rootIdentity),
+            ))
             {
                 throw new Error(`Plastic cannot resolve an owning repository for '${item.workspacePath}' outside the requested workspace.`);
             }
             let candidate = dirname(ownershipPath);
-            while (isWithinPathScope(toPathComparisonKeyFromAbsolutePath(candidate), toPathComparisonKeyFromAbsolutePath(root)))
+            while (isWithinPathScope(
+                toPathComparisonKeyFromAbsolutePath(await toFilesystemIdentityPath(candidate)),
+                toPathComparisonKeyFromAbsolutePath(rootIdentity),
+            ))
             {
                 // A missing ancestor can be a removed Xlink mount. Status does not
                 // retain ownership, so parent-repository fallback would be unsafe.
@@ -1873,7 +1912,8 @@ const createPendingBaseIdentityResolver = (cwd: string, workdir?: string): Pendi
                     item.baseRepository = `${repository.repository}@${repository.server}`;
                     return `revid:${item.revisionId}@rep:${repository.repository}@repserver:${repository.server}`;
                 }
-                if (candidate === root)
+                if (toPathComparisonKeyFromAbsolutePath(await toFilesystemIdentityPath(candidate))
+                    === toPathComparisonKeyFromAbsolutePath(rootIdentity))
                 {
                     break;
                 }