easyeda-mcp-pro 1.1.0 → 1.2.0

package/dist/package-build-manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "packageVersion": "1.1.0",
-  "sourceSha256": "689104fb72f62a94653365108e3c1227035216354b597d056927fa9821761857",
+  "packageVersion": "1.2.0",
+  "sourceSha256": "e1f24bbf698c647e27b5dd11a8413e0e84c35a51f36a3fd18bd2ae15d9749460",
   "artifacts": [
     {
       "path": "dist/bom-quality/adapter.d.ts",
@@ -110,33 +110,48 @@
     },
     {
       "path": "dist/bridge/listener-ownership.d.ts",
-      "size": 1035,
-      "sha256": "a304ea66ee7948d3882b969b5b7ede2fa780c21e2a76feaad9147cd189e40bf2"
+      "size": 1359,
+      "sha256": "bdd46f40c2f9362fa8f820454f63dbd25799721f33fce7a9dd144af8f7dad8d9"
     },
     {
       "path": "dist/bridge/listener-ownership.js",
-      "size": 9073,
-      "sha256": "d567cc43c8dd920d4625c6e2e55c353670c2121a85e0263c2b0130674a1aef6f"
+      "size": 9951,
+      "sha256": "3e7f3ea0d7038049529e61ffddcdab8c01d814e206b29bc16d9aa01646b08189"
     },
     {
       "path": "dist/bridge/listener-ownership.js.map",
-      "size": 8236,
-      "sha256": "faa5a592f7ca9cbba8dbd303179f1e251969c8d3cec95b32420735d0f1bb7f88"
+      "size": 8968,
+      "sha256": "743ee3958e5b8a8f7b5717b52203ff646702451920d6a42c561a421f894a398d"
+    },
+    {
+      "path": "dist/bridge/local-bridge-relay.d.ts",
+      "size": 1757,
+      "sha256": "35c80560e756c476ff72e7eb089e292499d5cfbd1ec536cd3f5e0c3849ed77e2"
+    },
+    {
+      "path": "dist/bridge/local-bridge-relay.js",
+      "size": 11920,
+      "sha256": "09cdce358590e8c23b44043a6a029e51adefa4517e17dbb1c650d81bc41e6093"
+    },
+    {
+      "path": "dist/bridge/local-bridge-relay.js.map",
+      "size": 11212,
+      "sha256": "ebafc53ffc33d13e2ea5c1ddf73909e01d9228569dc2e453e50c223c4e3c944e"
     },
     {
       "path": "dist/bridge/manager.d.ts",
-      "size": 4432,
-      "sha256": "f1cb9de5ee96405860ebc51c8374cec20c43660d93c0e39ce9cd64b90b58c935"
+      "size": 4855,
+      "sha256": "d39b5e82f6cc604f54967c562e0013f61fdb8749c603bf416282f64b8e4227e5"
     },
     {
       "path": "dist/bridge/manager.js",
-      "size": 32104,
-      "sha256": "dfd31c6d89e71f80c000c1ec5fb27edb30b1226afd998e5901150bb4b2d42f3f"
+      "size": 39621,
+      "sha256": "4a28d1292cbf2573fdc96a9182abf4b1e97d41a8b4dab95936042afe6e684ff8"
     },
     {
       "path": "dist/bridge/manager.js.map",
-      "size": 26073,
-      "sha256": "e131a8da5fd43f51f3fde42e5b5b6271c4ebdadd8bce5d97ed6d55d2bc26bea4"
+      "size": 32517,
+      "sha256": "39cafb104101496c8afa75bcdf2e5bb4d1eadc8b30ea5e40f95a1d5ffa6f2740"
     },
     {
       "path": "dist/bridge/protocol.d.ts",
@@ -155,18 +170,18 @@
     },
     {
       "path": "dist/bridge/types.d.ts",
-      "size": 3494,
-      "sha256": "a45720d96962ae33f8f3b54f19781379dd4b30ba86ee51db5c82dca9b912d0f8"
+      "size": 3540,
+      "sha256": "419f2b49f9c9b4d1f4739322c9054ebca5fda91c09768f01d306338b53303087"
     },
     {
       "path": "dist/bridge/types.js",
-      "size": 1951,
-      "sha256": "e00bd4a16c3c02cd488664088494e88d05fc8e1ea260a45a9bc408ccb520c9e9"
+      "size": 1976,
+      "sha256": "536bbac55b573a16d89fff17ca06eb841d24c9375b5167338fdc3af828eefb8d"
     },
     {
       "path": "dist/bridge/types.js.map",
-      "size": 1069,
-      "sha256": "42df270e3ad264456adfa4db1da137178e9c73f006f6a6c345340b605fc2981e"
+      "size": 1082,
+      "sha256": "5ae20c8f60ce271fbe70d3911f1846328c4dfe735a005df0617a5d25f62b2f04"
     },
     {
       "path": "dist/catalog/errors.d.ts",
@@ -476,7 +491,7 @@
     {
       "path": "dist/config/profiles.js",
       "size": 1615,
-      "sha256": "fc2eb5e9308216896c9e38490db61ba7e91ae606043e38bb1f47e8fee6a5b9fe"
+      "sha256": "db125176c23629fda56a16fcc0ad80a2bcba6f5b79f4597fa04a54e464d0466a"
     },
     {
       "path": "dist/config/profiles.js.map",
@@ -486,12 +501,12 @@
     {
       "path": "dist/config/version.d.ts",
       "size": 47,
-      "sha256": "4d66e92f315948eb0a7bede2a814e4b5bf37aa09873d36845e5b3e170d16b833"
+      "sha256": "b96ca94b9d291e107668a616a75dc59541e4b7e89ad77e43c93f1424b909f371"
     },
     {
       "path": "dist/config/version.js",
       "size": 102,
-      "sha256": "abddecccadf9dd45dcdffd33056193a1745c165607677c18c68af7d4b2ed3fe4"
+      "sha256": "7b5f35cc2678361240d142ae48dbf1fa28cb3ca9f611538630c7971b3523a8f3"
     },
     {
       "path": "dist/config/version.js.map",
@@ -2275,13 +2290,13 @@
     },
     {
       "path": "dist/tools/L1_pcb_write.js",
-      "size": 37972,
-      "sha256": "f7a618492a3c201c32f294c3338c53d60c2095329d1b509947664adbe31562bd"
+      "size": 51305,
+      "sha256": "c3da35b0d9169636e70afb92d1e298f445bead5abd0e8d64f9db7045e71158c2"
     },
     {
       "path": "dist/tools/L1_pcb_write.js.map",
-      "size": 31163,
-      "sha256": "149540ff8d58591cd94dd9fce57fde900beaa4252485c31e7f58bc5132b2fbc1"
+      "size": 42696,
+      "sha256": "4370110aad70d2ed2a5b6939be39fc45d31bd9ef5601130b6698f6bf080d1da4"
     },
     {
       "path": "dist/tools/L1_schematic_batch.d.ts",
@@ -2991,12 +3006,12 @@
     {
       "path": "easyeda-bridge-extension.checksums.json",
       "size": 1004,
-      "sha256": "ff0d255cc4f9e9fc0d821b26979317f93984699f6459d56b7935f79735b3e9a9"
+      "sha256": "a15f5bddd08f4f2c712eb8e3fdc56585010a2b2fc7f2c218b683e835ef2b7fb7"
     },
     {
       "path": "easyeda-bridge-extension.eext",
-      "size": 177756,
-      "sha256": "e3676b31a632e30a4ef2a556d6549bb0d8a8130e1e2f8e0fb96d182d0bb33746"
+      "size": 183089,
+      "sha256": "0b9932e7616ddd3f8e09d927ba33fb1181df842fe6d30e6065583b45a87cfaa1"
     }
   ]
 }

package/dist/tools/L1_pcb_write.js

@@ -67,6 +67,50 @@ const failClosedPcbWriteMetadata = {
         destructiveHint: false,
     },
 };
+const pcbRebuildCopperInputSchema = z
+    .object({
+    pourIds: z
+        .array(z.string().trim().min(1))
+        .min(1)
+        .max(100)
+        .refine((ids) => new Set(ids).size === ids.length, {
+        message: 'pourIds must not contain duplicates.',
+    })
+        .optional()
+        .describe('Optional existing PCB_PrimitivePour primitive ids to rebuild.'),
+    net: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe('Optional exact net-name filter. Combined with pourIds/layer when provided.'),
+    layer: z
+        .union([z.literal(1), z.literal(2), z.number().int().min(15).max(44)])
+        .optional()
+        .describe('Optional copper-layer filter: TOP=1, BOTTOM=2, INNER_1..INNER_30=15..44.'),
+    confirmWrite: z
+        .literal(true)
+        .describe('Must be the literal boolean true (not the string "true") to allow this write.'),
+})
+    .strict();
+const pcbRebuildCopperItemSchema = z.object({
+    pourId: z.string(),
+    pouredId: z.string().nullable(),
+    status: z.enum(['rebuilt', 'no-copper', 'error', 'readback-missing', 'readback-mismatch']),
+    verified: z.boolean(),
+    error: z.string().optional(),
+});
+const pcbRebuildCopperOutputSchema = z.object({
+    success: z.boolean(),
+    matchedCount: z.number().int().nonnegative(),
+    attemptedCount: z.number().int().nonnegative(),
+    rebuiltCount: z.number().int().nonnegative(),
+    noCopperCount: z.number().int().nonnegative(),
+    transactionCovered: z.literal(false),
+    planeZonesSupported: z.literal(false),
+    results: z.array(pcbRebuildCopperItemSchema),
+    error: z.string().optional(),
+});
 const failClosedPcbZoneInputSchema = z.object({
     points: z.array(z.object({ x: z.number(), y: z.number() })),
     layer: z.number(),
@@ -82,12 +126,217 @@ const failClosedPcbZoneOutputSchema = z.object({
     error: z.string().optional(),
     remediation: z.string().optional(),
 });
+const pcbPolygonTokenSchema = z.union([z.number().finite(), z.string().min(1)]);
+const pcbPolygonSourceSchema = z
+    .array(pcbPolygonTokenSchema)
+    .min(3)
+    .describe('EasyEDA TPCB_PolygonSourceArray, for example ["R", x, y, width, height, 0, 0] or a coordinate/L source array.');
+const pcbRegionPolygonSchema = z
+    .union([pcbPolygonSourceSchema, z.array(pcbPolygonSourceSchema).min(1)])
+    .describe('One EasyEDA polygon source array, or an array of source arrays for a complex polygon with multiple contours.');
+const pcbRegionRuleTypeSchema = z.enum([
+    'NO_COMPONENTS',
+    'NO_WIRES',
+    'NO_FILLS',
+    'NO_POURS',
+    'NO_INNER_ELECTRICAL_LAYERS',
+]);
+function pcbRegionRuleTypeValue(rule) {
+    switch (rule) {
+        case 'NO_COMPONENTS':
+            return 2;
+        case 'NO_WIRES':
+            return 5;
+        case 'NO_FILLS':
+            return 6;
+        case 'NO_POURS':
+            return 7;
+        case 'NO_INNER_ELECTRICAL_LAYERS':
+            return 8;
+    }
+}
+const pcbRegionLayerSchema = z
+    .union([z.literal(1), z.literal(2), z.literal(12), z.number().int().min(15).max(44)])
+    .describe('EasyEDA TPCB_LayersOfRegion layer: TOP=1, BOTTOM=2, MULTI=12, or INNER_1..INNER_30=15..44.');
+const pcbAddRegionInputSchema = z
+    .object({
+    layer: pcbRegionLayerSchema,
+    polygon: pcbRegionPolygonSchema,
+    ruleType: z
+        .array(pcbRegionRuleTypeSchema)
+        .min(1)
+        .max(5)
+        .describe('EPCB_PrimitiveRegionRuleType values to enforce in this region.'),
+    name: z
+        .string()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe('Optional native Region name. EasyEDA Pro 3.2.149 may omit this field on persisted read-back; when requested but not confirmed, the tool fails closed and rolls the Region back.'),
+    lineWidth: z
+        .number()
+        .positive()
+        .optional()
+        .describe('Optional native EasyEDA PCB line width. EasyEDA Pro 3.2.149 may normalize this field on persisted read-back; when requested but not confirmed, the tool fails closed and rolls the Region back.'),
+    locked: z.boolean().default(false),
+    confirmWrite: z
+        .literal(true)
+        .describe('Must be the literal boolean true (not the string "true") to allow this write.'),
+})
+    .strict();
+const pcbRegionReadBackSchema = z.object({
+    primitiveId: z.string(),
+    layer: z.number().optional(),
+    ruleTypes: z.array(z.number().int()),
+    regionName: z.string().optional(),
+    lineWidth: z.number().optional(),
+    locked: z.boolean(),
+    polygonSource: z.unknown().optional(),
+});
+const pcbAddRegionOutputSchema = z.object({
+    success: z.boolean(),
+    primitiveId: z.string().optional(),
+    ruleType: z.array(pcbRegionRuleTypeSchema).optional(),
+    ruleTypeValues: z.array(z.number().int()).optional(),
+    readBack: pcbRegionReadBackSchema.optional(),
+    rolledBack: z.boolean().optional(),
+    error: z.string().optional(),
+});
+function normalizedRuleTypes(value) {
+    return [...value].sort((a, b) => a - b);
+}
+function regionReadBackMatches(item, expected, ruleTypeValues) {
+    if (item.layer !== expected.layer)
+        return false;
+    if (JSON.stringify(normalizedRuleTypes(item.ruleTypes)) !==
+        JSON.stringify([...ruleTypeValues].sort((a, b) => a - b))) {
+        return false;
+    }
+    if (expected.name !== undefined && item.regionName !== expected.name)
+        return false;
+    if (expected.lineWidth !== undefined && item.lineWidth !== expected.lineWidth)
+        return false;
+    if (item.locked !== expected.locked)
+        return false;
+    return JSON.stringify(item.polygonSource) === JSON.stringify(expected.polygon);
+}
+const pcbRegionCreateResultSchema = z.object({
+    result: z.object({
+        state: z.object({ PrimitiveId: z.string().min(1) }),
+    }),
+});
+function primitiveIdFromApiCall(value) {
+    const parsed = pcbRegionCreateResultSchema.safeParse(value);
+    return parsed.success ? parsed.data.result.state.PrimitiveId : undefined;
+}
+async function listRegionsForWrite(ctx) {
+    const result = await ctx.bridge.call('pcb.listRegions', { limit: 200, offset: 0 });
+    const parsed = z.array(pcbRegionReadBackSchema).safeParse(result.items ?? []);
+    if (!parsed.success) {
+        throw new Error('PCB region read-back returned an unexpected shape.');
+    }
+    return parsed.data;
+}
+async function rollbackCreatedRegion(ctx, primitiveId) {
+    const deletion = await ctx.bridge.call('pcb.deleteComponent', { primitiveIds: [primitiveId] });
+    if (!deletion.deleted?.includes(primitiveId))
+        return false;
+    const remaining = await listRegionsForWrite(ctx);
+    return !remaining.some((item) => item.primitiveId === primitiveId);
+}
+function taggedRegionPolygon(polygon) {
+    return Array.isArray(polygon[0]) ? { $complexPolygon: polygon } : { $polygon: polygon };
+}
+function findCreatedRegion(after, beforeIds, returnedPrimitiveId) {
+    if (returnedPrimitiveId) {
+        const exact = after.find((item) => item.primitiveId === returnedPrimitiveId);
+        if (exact)
+            return exact;
+    }
+    const added = after.filter((item) => !beforeIds.has(item.primitiveId));
+    return added.length === 1 ? added[0] : undefined;
+}
+async function failedRegionWrite(ctx, parsed, ruleTypeValues, message, primitiveId, readBack) {
+    let rolledBack;
+    if (primitiveId) {
+        try {
+            rolledBack = await rollbackCreatedRegion(ctx, primitiveId);
+        }
+        catch {
+            rolledBack = false;
+        }
+    }
+    return {
+        success: false,
+        ...(primitiveId ? { primitiveId } : {}),
+        ruleType: parsed.ruleType,
+        ruleTypeValues,
+        ...(readBack ? { readBack } : {}),
+        ...(rolledBack !== undefined ? { rolledBack } : {}),
+        error: rolledBack === false
+            ? `${message}; rollback could not be verified.`
+            : rolledBack === true
+                ? `${message}; the created region was rolled back.`
+                : message,
+    };
+}
+async function handlePcbAddRegion(ctx, params) {
+    const result = pcbAddRegionInputSchema.safeParse(params);
+    if (!result.success)
+        return { success: false, error: result.error.message };
+    const parsed = result.data;
+    const ruleTypeValues = parsed.ruleType.map(pcbRegionRuleTypeValue);
+    try {
+        const before = await listRegionsForWrite(ctx);
+        const beforeIds = new Set(before.map((item) => item.primitiveId));
+        const created = await ctx.bridge.call('api.call', {
+            path: 'PCB_PrimitiveRegion.create',
+            args: [
+                parsed.layer,
+                taggedRegionPolygon(parsed.polygon),
+                ruleTypeValues,
+                parsed.name,
+                parsed.lineWidth,
+                parsed.locked,
+            ],
+        });
+        const returnedPrimitiveId = primitiveIdFromApiCall(created);
+        let after;
+        try {
+            after = await listRegionsForWrite(ctx);
+        }
+        catch (error) {
+            return failedRegionWrite(ctx, parsed, ruleTypeValues, `PCB_PrimitiveRegion.create returned but persisted read-back failed: ${error instanceof Error ? error.message : String(error)}`, returnedPrimitiveId);
+        }
+        const readBack = findCreatedRegion(after, beforeIds, returnedPrimitiveId);
+        if (!readBack) {
+            return failedRegionWrite(ctx, parsed, ruleTypeValues, 'PCB_PrimitiveRegion.create returned without a unique matching PCB_PrimitiveRegion.getAll read-back', returnedPrimitiveId);
+        }
+        if (!regionReadBackMatches(readBack, parsed, ruleTypeValues)) {
+            return failedRegionWrite(ctx, parsed, ruleTypeValues, 'PCB region read-back did not match the requested layer/rules/name/width/lock state', readBack.primitiveId, readBack);
+        }
+        return {
+            success: true,
+            primitiveId: readBack.primitiveId,
+            ruleType: parsed.ruleType,
+            ruleTypeValues,
+            readBack,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 const failClosedPcbZoneTool = {
     name: 'easyeda_pcb_add_zone',
     title: 'Add PCB copper zone/pour (unavailable)',
-    description: 'PCB copper-zone creation is unavailable because the verified EasyEDA Pro runtime requires ' +
-        'a complete native argument contract that this integration has not yet recovered. This tool ' +
-        'fails closed and does not call the bridge.',
+    description: 'PCB copper-zone creation is unavailable because the verified EasyEDA Pro 3.2.149 runtime ' +
+        'does not provide a trustworthy create/rebuild/associated-Poured read-back contract. The ' +
+        'native create signature is known, but rebuild association and persistence remain unsafe. ' +
+        'This tool fails closed and does not call the bridge.',
     ...failClosedPcbWriteMetadata,
     version: '2.0.0',
     inputSchema: failClosedPcbZoneInputSchema,
@@ -96,7 +345,7 @@ const failClosedPcbZoneTool = {
         success: false,
         not_available: true,
         error: 'PCB copper-zone creation is not supported by the verified EasyEDA Pro runtime.',
-        remediation: 'Create or edit the copper zone in EasyEDA Pro manually until the complete native zone-creation contract is live-verified.',
+        remediation: 'Create or edit the copper zone in EasyEDA Pro manually until a supported runtime has a live-verified deterministic create/rebuild/associated-Poured read-back contract.',
     }),
 };
 export async function applyLayoutOperations(ctx, operations) {
@@ -559,6 +808,27 @@ function registerPcbWriteTools(registry, _config) {
                 'easyeda_pcb_modify_component.',
         }),
     });
+    registry.register({
+        name: 'easyeda_pcb_add_region',
+        title: 'Add PCB constraint region',
+        description: 'Create a native EasyEDA PCB Region/keepout from a typed polygon and documented rule values. ' +
+            'This is not a copper pour/zone. Success requires getAll-backed read-back; unconfirmed ' +
+            'optional name/lineWidth values cause rollback.',
+        profile: 'full',
+        evidence: ['official-docs', 'runtime-probe'],
+        risk: 'high',
+        confirmWrite: true,
+        group: 'pcb-write',
+        version: '1.0.0',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        inputSchema: pcbAddRegionInputSchema,
+        outputSchema: pcbAddRegionOutputSchema,
+        handler: async (ctx, params) => handlePcbAddRegion(ctx, params),
+    });
     registry.register({
         name: 'easyeda_pcb_add_track',
         title: 'Add PCB track',
@@ -669,6 +939,64 @@ function registerPcbWriteTools(registry, _config) {
             }
         },
     });
+    registry.register({
+        name: 'easyeda_pcb_rebuild_copper',
+        title: 'Rebuild existing PCB copper pours',
+        description: 'Rebuild existing PCB_PrimitivePour copper via the beta rebuildCopperRegion() API and verify each ' +
+            'result through PCB_PrimitivePoured read-back. Requires confirmWrite. PCB rebuilds are not ' +
+            'transaction-covered; after timeout inspect before retry. PlaneZone objects are unsupported.',
+        profile: 'full',
+        evidence: ['official-docs', 'pro-api-types', 'official-skill'],
+        risk: 'high',
+        confirmWrite: true,
+        sideEffect: 'design-mutation',
+        group: 'pcb-write',
+        version: '1.0.0',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        inputSchema: pcbRebuildCopperInputSchema,
+        outputSchema: pcbRebuildCopperOutputSchema,
+        handler: async (ctx, params) => {
+            const parsed = pcbRebuildCopperInputSchema.safeParse(params);
+            if (!parsed.success) {
+                return {
+                    success: false,
+                    matchedCount: 0,
+                    attemptedCount: 0,
+                    rebuiltCount: 0,
+                    noCopperCount: 0,
+                    transactionCovered: false,
+                    planeZonesSupported: false,
+                    results: [],
+                    error: parsed.error.message,
+                };
+            }
+            const { confirmWrite: _confirmWrite, ...bridgeParams } = parsed.data;
+            try {
+                return await ctx.bridge.call('pcb.rebuildCopper', bridgeParams);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const timedOut = /timed?\s*out|timeout/i.test(message);
+                return {
+                    success: false,
+                    matchedCount: 0,
+                    attemptedCount: 0,
+                    rebuiltCount: 0,
+                    noCopperCount: 0,
+                    transactionCovered: false,
+                    planeZonesSupported: false,
+                    results: [],
+                    error: timedOut
+                        ? `${message}. PCB copper rebuilds are not transaction-covered; the write outcome is unknown. Inspect the active PCB before retrying.`
+                        : message,
+                };
+            }
+        },
+    });
     registry.register(failClosedPcbZoneTool);
     registry.register({
         name: 'easyeda_pcb_add_text',