@modular-circuit/transpiler 0.0.109 → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,2936 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/converter/kicad_sexpr/eeschema/drawing_sheet/index.ts
+import { Base64 } from "js-base64";
+
+// src/converter/kicad_sexpr/eeschema/drawing_sheet/sch_default_drawing_sheet.ts
+var BASE_64_ENCODED_SCH_DEFAULT_DRAWING_SHEET = "(kicad_wks
	(version 20231118)
	(generator "pl_editor")
	(generator_version "8.0")
	(setup
		(textsize 1.5 1.5)
		(linewidth 0.15)
		(textlinewidth 0.15)
		(left_margin 10)
		(right_margin 10)
		(top_margin 10)
		(bottom_margin 10)
	)
	(rect
		(name "")
		(start 135.669 34.2722)
		(end 2 2.0002)
		(comment "rect around the title block")
	)
	(rect
		(name "")
		(start 0 0 ltcorner)
		(end 0 0)
		(repeat 2)
		(incrx 2)
		(incry 2)
	)
	(line
		(name "")
		(start 50 2 ltcorner)
		(end 50 0 ltcorner)
		(repeat 30)
		(incrx 50)
	)
	(tbtext "1"
		(name "")
		(pos 25 1 ltcorner)
		(font
			(size 1.3 1.3)
		)
		(repeat 100)
		(incrx 50)
	)
	(line
		(name "")
		(start 50 2 lbcorner)
		(end 50 0 lbcorner)
		(repeat 30)
		(incrx 50)
	)
	(tbtext "1"
		(name "")
		(pos 25 1 lbcorner)
		(font
			(size 1.3 1.3)
		)
		(repeat 100)
		(incrx 50)
	)
	(line
		(name "")
		(start 0 50 ltcorner)
		(end 2 50 ltcorner)
		(repeat 30)
		(incry 50)
	)
	(tbtext "A"
		(name "")
		(pos 1 25 ltcorner)
		(font
			(size 1.3 1.3)
		)
		(justify center)
		(repeat 100)
		(incry 50)
	)
	(line
		(name "")
		(start 0 50 rtcorner)
		(end 2 50 rtcorner)
		(repeat 30)
		(incry 50)
	)
	(tbtext "A"
		(name "")
		(pos 1 25 rtcorner)
		(font
			(size 1.3 1.3)
		)
		(justify center)
		(repeat 100)
		(incry 50)
	)
	(line
		(name "")
		(start 135.669 29.192)
		(end 49.309 29.192)
	)
	(line
		(name "")
		(start 135.669 24.112)
		(end 49.309 24.112)
	)
	(line
		(name "")
		(start 135.669 19.032)
		(end 2 19.032)
	)
	(line
		(name "")
		(start 49.309 34.2722)
		(end 49.309 19.0322)
	)
	(tbtext "Document Name:"
		(name "")
		(pos 134.399 31.7322)
		(font
			(face "Arial") bold)
	)
	(tbtext "${TITLE}"
		(name "")
		(pos 116.699 31.7322)
		(font
			(face "Arial")
		)
	)
	(tbtext "Project Name:"
		(name "")
		(pos 134.399 26.6522)
		(font
			(face "Arial") bold)
	)
	(tbtext "${COMMENT3}"
		(name "")
		(pos 119.699 26.6522)
		(font
			(face "Arial")
		)
	)
	(tbtext "Sheet Name:"
		(name "")
		(pos 134.399 21.5722)
		(font
			(face "Arial") bold)
	)
	(tbtext "${FILENAME}"
		(name "")
		(pos 121.099 21.5722)
		(font
			(face "Arial")
		)
	)
	(line
		(name "")
		(start 135.669 13.952)
		(end 2 13.952)
	)
	(tbtext "Author:"
		(name "")
		(pos 134.399 16.4922)
		(font
			(face "Arial") bold)
	)
	(tbtext "${COMMENT2}"
		(name "")
		(pos 126.199 16.4922)
		(font
			(face "Arial")
		)
	)
	(line
		(name "")
		(start 135.669 8.872)
		(end 2 8.872)
	)
	(tbtext "Date:"
		(name "")
		(pos 48.039 11.4122)
		(font
			(face "Arial") bold)
	)
	(tbtext "${ISSUE_DATE}"
		(name "")
		(pos 42.139 11.4122)
		(font
			(face "Arial")
		)
	)
	(tbtext "Sheet Number:"
		(name "")
		(pos 134.399 11.4122)
		(font
			(face "Arial") bold)
	)
	(tbtext "${#} of ${##}"
		(name "")
		(pos 118.699 11.4122)
		(font
			(face "Arial")
		)
	)
	(tbtext "Revision:"
		(name "")
		(pos 87.409 11.4122)
		(font
			(face "Arial") bold)
	)
	(tbtext "${REVISION}"
		(name "")
		(pos 77.209 11.4122)
		(font
			(face "Arial")
		)
	)
	(line
		(name "")
		(start 49.309 13.9522)
		(end 49.309 8.8722)
	)
	(line
		(name "")
		(start 88.679 13.9522)
		(end 88.679 8.8722)
	)
	(tbtext "Modular Circuit Design Studio designs are machine-generated drafts and require verification by qualified specialists. \nBy using these designs, you agree to the eda.cn Terms of Use: ${COMMENT1}"
		(name "")
		(pos 134.399 6.332)
		(font
			(face "Arial")
		)
	)
	(bitmap
		(name "")
		(pos 25.408 26.906)
		(scale 0.7580645161)
		(data "iVBORw0KGgoAAAANSUhEUgAAAI4AAAAyCAYAAACK9eMGAAAACXBIWXMAAA7DAAAOwwHHb6hkAAAA"
			"GXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAEEBJREFUeJztnXmcVNWVx7+/V+9V"
			"IyIEBHH7mBhlHDf8RBpnkoxL3GfUcZ02xGVssLsKneASt8G4kMRtJCQqhH7d8MG4D+5LNI64xy12"
			"k0GNY+IWMAh+RCGySHdVvTN/vNft6+raeqNR+H4+9aHeffeec6vrcN+55557S2ZGMVqknYDjgX8B"
			"dgZ2AAYXbdC3tAHLgSUGTxo8MN7sfzeQbiRt7cE3OpXB+lazP+bVG+nB1+NlGVhmZh9ugG629yEJ"
			"jPJglMG2Bltmze4t186VTnBgZLwsA/eZ2YqyOgsZziJphwxcLpgIuN34DP2KYEEAF1Wb/aG/dXnS"
			"E8ChecWXZ8x+Gi9ISvUGfl69aRmzK0vJl7Slma0t1w9JQ12YajDUgSEGWwFDgOHRv9tE7+N8mDHb"
			"oZxsT2oGxnXSB9VtZi3l2nYxioXSkQZ3CYaVa7yhMThU8GqLdOk4s+v6S48rna48oxF8kIGf91a2"
			"pCEuXJCA0yXtZmaZMk2GABcLKP5s2PA48YtmKWXwCBuh0cRIANculG7qD+GSthZMzy8P4HwzW9cL"
			"uXKl0114B7hCsHMidAO+lHQYzkLpCMFMwi9mo8fgP1qkc/pSpiTHhVuBUXm3fpM1u6encj3pQBd+"
			"L/g1MLpDH0zpqcwC/A54wGAu8KuY7h950oftr6R0c4V9PizezpMWxu+7AC3SSOAuNiJ/pkKmt0hP"
			"jTN7vS+EufAT4J/zildk4cyeyKuSxgZwDeHkogsG20saZmZ/KyHmM+AiwacBrBSsBKYB+8crZcz2"
			"L9g69Im2i+ncupK+GwxSrF0+7YZyOfC1SgRuZLjA1cAxvRYkHS+Yml9ukDKz5d2RZbBTUrrV4Afk"
			"uQMRa4FrcvBzM1tfUpbZGuD6eJknnded/vQH7uvScCBVpp4ZPO7AU0Cp/x19hoEr2NVgArBtiapH"
			"vyrtOT5vmtwdXOkowR2A8m49mzW7r7vyBLVFHFkT3JOBC81scfd7uvHgtsLRgmSJOqsNTqg2W7DB"
			"ehXjNemyTOh3FHUkE3As0CPDiYzmHmBQgduf9URmEZ4HLm4ze6kPZQ4YjuDIUhUEZw2U0QCMNVu7"
			"Ohzy3ypR7fCeyE5KZwrup7DRlETSIFc6zSBdpuqTwEEZswMyXxGjgdBH2KnE/eX7hkP4gHKQ2fqW"
			"cPo9q9B9K/0ZuiBpKw9mG5zSzXYJFw40OMmF79M18BbnMeBnGbMXu6Mjn6R0dgBj42UOjM1/FCal"
			"+e3vDd7LmF3SG73lcIHtS9x/HbOgPztQKQaL8h2QGEW9/3wkDUnAQoNdu6N/kDTGhReAUSX6EeqA"
			"ujazOd2RXwyDI5Tn/Bfynwz+LXZZNvLbW1xKDNMGXTz+FukyYL8i9d+pNqvI42+WJih8BFUkx4H1"
			"JSKnFT9qzGxNUmouYDh/AnYr1i6AoXSN7xSr+1Gxe4OkXbKwb7wsBw+ZWWslsvuYLr6tQVUlDXsS"
			"t9kPOLrQDcHCQuVF2K2P5HSbDJznhvGaYQAGjQ7MM+iuD/Im8BeKxGkKkYNTFMZh2skCW3RTb58g"
			"GFbgP+NWlbQtFGP4ymNmy6Mvb43BqVmzFFBuzaidT6Lo7P4Zsz0FD3ZLN+yYd/2BmWWL1U/A+YJq"
			"QbXBaUWqrTSoaX8BFfk3Fo6i+WUVLTd92SLFfUYGbqqCh9abvVth/aUuHJ6Fp0t90RFFH53Kc3QF"
			"75cStN7snfb3SenbRR7Xn2fN7i7Tp879CBdbuxiJ8lJEirHJGk705VdkNFH95YT5QZVwnSftQWcf"
			"MSHYG/iHTnLDR12lFFtWQNIgD35gcHwWTjSztlKCPNjLugY8EexZSUc2WcPpKwJYm//XV5j0dmV+"
			"3UKjheD/KtETLcAeVOT21i58YFFSlgdnAI2R/IeBjqQyg/aI9d6FBFk0IuZgkRdbUQjCZZIONhtO"
			"L8nBMy6spkKnMo/WRBiALIsLBxImbRWiis6zoUsl3WxmbVFSVqHp+cFFZI2VNNLMlhAZXyE2See4"
			"LzGzpYSzw2bCGVIltAKLDGoq9bEip7cUy2J1d4pGnYJIqrLiM8FEAo4o15/NI04PSEq3GeweK/o4"
			"Yza+v/RJcl04MVaUo2ve1Bzgstj11PZRJ19eZBhdZlQd+uA44PZSfeprw9mlRXq4koqCv+tj3b0i"
			"A4u9vCyBmD9AXvnudA7iLStUr69IhOuJ8eDjS8A/xesIHjGoJZruG3w97uvk1f1RGZXHStohGk0L"
			"0teGM4wiQb2NnSizv+gzfSARTI5dfgY8R57hEI5Cc4ErYmWX5o86nvQd4IC8tlk624LnwiTCxLaC"
			"bJKPqqQ0znqX/JW/NraVJ13ZC3nPZMyeKXRD0jfczhkMCygSrMxCkwuXEn2vBm8AI4jCCNHM7PoC"
			"TX9CONrGd0b8UNINxbITN0nDIdwSckXZWpUzpA/kPVOo0A3TNjomMYLfFMsGMLOlXugqDCXcytNp"
			"Zd6DKQbfyWu2Ogs3ueDR2Uca6cKFwI8L6do8q9qIUZidGc/3yWXg0VJtsnB6xuzQfKOpksYa/KxA"
			"kyYzW5WFJsLHXZzzJBWMJG82nI0YF86l87LAE+Xyn6Mc5U5IGpmDB4At826ty8IvonYfCPJ3fw52"
			"YZ6kLnayqT6qWui8Qt1d6uns56yhd5v1nilUqHBBtQODed0VHK1J3U8Yzc7nCjP7a/uFA1NzYRpu"
			"PJj4PQ9+CNwQb9jXhrOCCiOhhH7GvmVr9QMloqkV4UnH0NlwVpfb8tsT2sxu9KTtCFe7l0ajRsVI"
			"2tINlxzyZ2AAi7J5xrDe7F1PupHQt+nA4HpPWhR34PvacJaMM6uvpGKzdKUGyHC+TGRhaiLMOvxz"
			"uYXLOJJGuWHKx7cLiRXUFtp+nIWrXDid2MZBQsd5vqT9zOwvsNnH2egxM8tBOlsk37oQVdJeCXiF"
			"wkaD4Jy2Igc3RNPvM+i6JjvKhf9ROAJuNpwvA2aWreRki3YCaFBhnwZgepvZr4rcAyBj9lvyHmMR"
			"Y1x4QtKozYbzFcQJnfdCByTcl4WLK5GRDf2qQim8o5KwzWbD+QrSavam4Py84nuzcIpVuGvFzFqz"
			"cIw6r9d95MAhrWZ/3Gw4X1HazHyFB0kA3JiFmnL71PMxsw8Vpl98KvggAfu3mr0Bm24cp7c8Ryyr"
			"TvDJBtb/O6DTwVKZAmmtGTjLgwVtZnN7qqjV7M2kdFQCPvrcrCM/+ktjODlYqvBkqs8Eow32Icwr"
			"2VBnEnaQqXDvWD/qX0C42FkSM1tJuGLeK9rMXs4v64nh/L7YDQtPm6qUPxGe/lWRnPFhqP2/4mUt"
			"0jDBhQYXdUPvZvqCZni7GazQ61V4zMzYWF7zIfEijHga3Hj5q/Ddge5bsVcqlTq1P+XX19d7A/G5"
			"HIs9q/NRN/dX9xevSuNbpEe+CWuT8MlWsK5FerxZ+i5AtdkLA93HYlg/HnIJIOnJdDq9R3/qKIRT"
			"ZkPYrs3SQRuqM4VYKJ3qhJv9j+KLxTcPOFzwbLM0aeB6N/Akk8nDGhoa3uyNjFQq5aVSqW4dGKpX"
			"4fuCO0vUWWxwcLXZe73pXE9okfYm3D1Q6uCnjMG+1dE0sRw1NTWJ4cOHv9DW1nbkvHnzVtXX1/8r"
			"cGhjY+MUgPr6+jskvS9pcUNDQ2NNTU1ixIgRT5vZIb7vZ1Kp1JnAjpJ2b2hoOBkgnU7/MgiC+Y2N"
			"jS/W1dXt7DjONN/3TwdIpVLLCBO/683sNc/zTmpraxvjOM4Bvu9fFek8R9I2vu9fWldXNzaRSMw0"
			"szFm9rSkf/d9P1NfXz8euMpxnBHAT4MgOLKxsXFyKpVqchznhiAIjg2C4LmmpqbnI70PBkFwQ1NT"
			"01Ptn72+vv4ISVOBoWZ2e2Nj4/R0On2ymc0mnGQszOVyE+bMmbM4lUrdGum/AFgs6RIzu5Ywp3mK"
			"q/Acl88pvvH964KFzdKsBDxlsKqSL6inGKwa98WWkYspbTQAXpR8XVuJ/Pnz5+fS6XRLVVXVicBc"
			"SROA/VOp1CWe520haVdJ1wVB0Ag0Dh8+/AAz20fSYcCjZnZKMpk8I5PJPDVp0qTtXdf9GDguOt38"
			"RUknSoonUW0LLK2qqtqxtbX10mw2e0EikXjWzDqy+KKErZHR+2ozO9f3/YWpVGqGmdVMmjTpIdd1"
			"pwMnDh48eO2aNWtucRynfUlhdDabrXIcZ6dEIvG1mMwdEolER/5NOp3eR9Jc4ETP897JZDLn1NXV"
			"jXUc52rCrMAlQFMikWgEjpC0u6T31q1bN37w4MF3ATOAY4Ig+MdEIjHNGWf2N0G5M4OHCaYGsMCg"
			"uZ9fV8X0HlKJMVB8c1lBcrncrWY2oba2dhCwl6QGMzu6ra3tWDOb39DQsEhSVTqdHiPpJElnm9mE"
			"urq60ZJs5syZi4E7XdetkXQIYfZcdSqV8iQd67pufB/3Ct/3f3HjjTd+FgTB/cCYUn3LZrMPSzoo"
			"nU7/0sy2BnbxPO8ISY/6vr9ixowZn0sqmkReglPNbJ7v+6/MnDnzE9/3L3cc5zBJ9/m+/5bv++sc"
			"x5kOHDZlypSh0d/p5ltuuWWtmf3WzF6O6jxvZjs7AB5cS5hLszEQX2MpdeJVnNHlq3xBU1PTy8B2"
			"nudNBB7MZrO3SjpZ0glBELR/6bcGQTAhCIIxDQ0Nt0na1XGcUxWdfCXp14Sncp0QBMEdhNl5ZwAr"
			"Z86cGQ8IxlMhMoQ/gxAQC4WYWQJg2rRpjud5TwJvOo4zG1gRZd8lzKzcGUDWLie6cPNutkpanVf2"
			"eRAEQ9qvc7ncWiDnum4GIAiC1uizZqK+4/t+BnAcgL3NVgpOyPuQA4I6G8sHFTb7a/kqXbhd0jWS"
			"7pgzZ85iwhTNqug9ruveLulcSQsAzOx+4D8tOii7oaHhbSAwsx2bmprel3S7pOlm9t8TJ04cNXHi"
			"xFKHML0LjKutrR109tlnbyvpJIAlS5ZsCQz99NNPnxo9evS7ksYAJBKJZ4Ha+vr6AydPnryNmRU6"
			"GPxtooSturq6g4E9AM4///wtzjrrrG86jnOXpJpUKjWstrZ2UDqdnibpEUkHTZ48ea9UKjUYuMjM"
			"Zs+YMePzcn+8jrWqfc2eNziLrgnLG5r41LKijDfBQz3QcxvwRPuMxMzmEUvNnDVr1nLgbtd17wRw"
			"XfdOM7vb9/2OkdnMZpnZ7QCRnMc8z3vQ87yTXNc9DkDSkpjOdcC7vu+/BdybTCbfy2azT5rZTcCS"
			"uXPnrgZuGj58+EvLli17GVhtZiujvkyVdEcQBK9LiufSvAusc13XB/4+lUotdxznQuDqXC63avXq"
			"1dXZbPbc2bNnvxEEwSXAXZ7nLQDW+b6/RNJpZnYD8IrjOGtWrVp1XvTZliaTySxAEAQfS4qHbV7r"
			"8usx7T8CwgD+noMDe37L7M0/SKMCeI3S5xx/HMDY8d08xPrLzKRJk7b3PO+hhoaG6oHqQ5fV8X3D"
			"JJ7dKbxdYoMQRHuUvmX2cbQ5vthW1I8Mjt6UjGZjoWBaxTizZePM6oMwi2wK8DjwZwonB/UHNe2B"
			"vei3qfY0+HF0Rt97wMuCK9tgj2qzomtnX1WGDRu2MnrsDBj/D2KTzzdbovZyAAAAAElFTkSuQmCC"
		)
	)
)
";
+
+// src/converter/kicad_sexpr/eeschema/drawing_sheet/index.ts
+function get_sch_default_drawing_sheet() {
+  return Base64.decode(BASE_64_ENCODED_SCH_DEFAULT_DRAWING_SHEET);
+}
+
+// src/converter/kicad_sexpr/eeschema/printer.ts
+import { READABLE_ELECTRICAL_PINTYPE } from "@modular-circuit/electronics-model";
+import {
+  SHAPE_T
+} from "@modular-circuit/ir";
+import { gen_uuid } from "@modular-circuit/utils";
+
+// src/utils/collect_sub_sheets.ts
+import { KICAD_SHC_FILE_EXT, parse_module_name, remove_filename_path_prefix, unzipFile } from "@modular-circuit/utils";
+async function collect_sub_sheets(dependencies, module_resolver) {
+  const sheets = {};
+  const module_main_sheet = {};
+  const modules = {};
+  for (const [k, v] of Object.entries(dependencies)) {
+    const zip_archive_url = await module_resolver.get_module_archive({
+      ...parse_module_name(k),
+      version: v
+    });
+    const module = await module_resolver.get_module_circuit({
+      ...parse_module_name(k),
+      version: v
+    });
+    if (!zip_archive_url || !module) {
+      console.error(`Module ${k}/${v} not found`);
+      continue;
+    }
+    if (!module.main) {
+      console.error(`Missing main entry in module ${k}/${v}`);
+      continue;
+    }
+    module_main_sheet[k] = module.main;
+    modules[k] = module;
+    const zip_archive = await fetch(zip_archive_url).then((res) => res.arrayBuffer());
+    const files = await unzipFile(zip_archive);
+    for (const [name, content] of Object.entries(files)) {
+      if (name.endsWith(KICAD_SHC_FILE_EXT)) {
+        const fileName = remove_filename_path_prefix(name);
+        if (fileName in sheets) {
+          console.error(`Duplicate sheet name: ${fileName}`);
+          continue;
+        }
+        sheets[fileName] = content;
+      }
+    }
+  }
+  return { sheets, module_main_sheet, modules };
+}
+
+// src/utils/constraints.ts
+var PAPER_SIZE = {
+  A0: { width: 841, height: 1189 },
+  A1: { width: 594, height: 841 },
+  A2: { width: 420, height: 594 },
+  A3: { width: 297, height: 420 },
+  A4: { width: 210, height: 297 },
+  A5: { width: 148, height: 210 },
+  A6: { width: 105, height: 148 },
+  A7: { width: 74, height: 105 },
+  A8: { width: 52, height: 74 }
+};
+var DEFAULT_PAPER_SIZE = PAPER_SIZE.A4;
+var GENERATOR_NAME = "modular_circuit";
+var SCH_VERSION = 20231120;
+var PAPER = "A4";
+var GENERATOR_VERSION = "8.0";
+
+// src/utils/filter_null_undefined.ts
+function filterNullOrUndefined(originalMethod, _context) {
+  function replacementMethod(...args) {
+    if (args.length === 0 || args.length === 1 && (args[0] === void 0 || args[0] === null)) return "";
+    const result = originalMethod.call(this, ...args);
+    return result;
+  }
+  return replacementMethod;
+}
+
+// src/utils/string_formatter.ts
+var tab = "	";
+var StringFormatter = class {
+  constructor(intend = 0) {
+    this.intend = intend;
+    this.content = "";
+  }
+  toString() {
+    return this.content;
+  }
+  get intend_level() {
+    return this.intend;
+  }
+  enter_scope() {
+    this.intend += 1;
+  }
+  exit_scope() {
+    this.intend -= 1;
+  }
+  append(str) {
+    this.content += str;
+  }
+  append_line(str) {
+    this.content += `${tab.repeat(this.intend)}${str}`;
+  }
+  append_quote(str) {
+    this.append(`"${str}"`);
+  }
+};
+
+// src/utils/collect_sub_sheets_by_id.ts
+import {
+  fmt_module_name,
+  KICAD_PCB_FILE_EXT,
+  KICAD_SHC_FILE_EXT as KICAD_SHC_FILE_EXT2,
+  remove_filename_path_prefix as remove_filename_path_prefix2,
+  unzipFile as unzipFile2
+} from "@modular-circuit/utils";
+async function collect_sub_sheets_by_id(module_ids, module_resolver) {
+  const sheets = {};
+  const boards = {};
+  const module_main_sheet = {};
+  const modules = {};
+  for (const id of module_ids) {
+    const zip_archive_url = await module_resolver.get_module_archive_by_id(id);
+    const module_circuit = await module_resolver.get_module_circuit_by_id(id);
+    if (!module_circuit) {
+      console.error(`Module ${id} not found`);
+      continue;
+    }
+    if (!zip_archive_url || !module_circuit) {
+      console.error(`Module ${module_circuit.author}/${module_circuit.name} not found`);
+      continue;
+    }
+    if (!module_circuit.main) {
+      console.error(`Missing main entry in module${module_circuit.author}/${module_circuit.name}`);
+      continue;
+    }
+    const k = fmt_module_name(module_circuit);
+    module_main_sheet[k] = module_circuit.main;
+    modules[k] = module_circuit;
+    const zip_archive = await fetch(zip_archive_url).then((res) => res.arrayBuffer());
+    const files = await unzipFile2(zip_archive);
+    for (const [name, content] of Object.entries(files)) {
+      if (name.endsWith(KICAD_SHC_FILE_EXT2)) {
+        const fileName = remove_filename_path_prefix2(name);
+        if (fileName in sheets) {
+          console.error(`Duplicate sheet name: ${fileName}`);
+          continue;
+        }
+        sheets[fileName] = content;
+      } else if (name.endsWith(KICAD_PCB_FILE_EXT)) {
+        const fileName = remove_filename_path_prefix2(name);
+        if (fileName in boards) {
+          console.error(`Duplicate module name: ${fileName}`);
+          continue;
+        }
+        boards[fileName] = content;
+      }
+    }
+  }
+  return { sheets, module_main_sheet, modules, boards };
+}
+
+// src/converter/kicad_sexpr/eeschema/printer.ts
+var SCOPE_START = "\n	";
+var SPACE = " ";
+var SCOPE_END = "\n";
+var IGNORE_BOOLEANS = /* @__PURE__ */ new Set(["power"]);
+var _color_dec, _stroke_dec, _fill_dec, _fields_dec, _justify_dec, _lib_id_dec, _unit_dec, _pin_defs_dec, _drawings_dec, _lib_children_dec, _pin_display_opt_dec, _power_dec, _init;
+_power_dec = [filterNullOrUndefined], _pin_display_opt_dec = [filterNullOrUndefined], _lib_children_dec = [filterNullOrUndefined], _drawings_dec = [filterNullOrUndefined], _pin_defs_dec = [filterNullOrUndefined], _unit_dec = [filterNullOrUndefined], _lib_id_dec = [filterNullOrUndefined], _justify_dec = [filterNullOrUndefined], _fields_dec = [filterNullOrUndefined], _fill_dec = [filterNullOrUndefined], _stroke_dec = [filterNullOrUndefined], _color_dec = [filterNullOrUndefined];
+var SCHEMATIC_PRINTER = class {
+  constructor() {
+    __runInitializers(_init, 5, this);
+  }
+  schematic(sch) {
+    const lib_symbols = (() => {
+      if (!sch.lib_symbols?.symbols.length) return "";
+      return `${SCOPE_START}(lib_symbols ${sch.lib_symbols?.symbols.map((it) => this.lib_symbol(it)).join(`${SCOPE_END}`)}	)`;
+    })();
+    const wires = (() => {
+      if (!sch.wires?.length) return "";
+      return `${SCOPE_START}${sch.wires.map((it) => this.wire(it)).join(`${SCOPE_END}`)}	`;
+    })();
+    const labels = (() => {
+      if (!sch.labels?.length) return "";
+      return `${SCOPE_START}${sch.labels.map((it) => this.label(it)).join(`${SCOPE_END}`)}`;
+    })();
+    const sch_sheets = (() => {
+      if (!sch.sheets?.length) return "";
+      return `${SCOPE_START}${sch.sheets.map((it) => this.sch_sheet(it)).join(`${SCOPE_END}`)}	`;
+    })();
+    const sch_symbols = (() => {
+      if (!sch.symbols?.length) return "";
+      return `${SCOPE_START}${sch.symbols.map((it) => this.sch_symbol(it)).join(`${SCOPE_END}`)}	`;
+    })();
+    return `
+(kicad_sch
+    (version ${SCH_VERSION})
+    (generator "${GENERATOR_NAME}")
+    (generator_version "${GENERATOR_VERSION}")
+    (uuid "${gen_uuid()}")
+    (paper "${PAPER}")
+    ${lib_symbols}
+    ${wires}
+    ${labels}
+    ${sch_symbols}
+    ${sch_sheets}
+)
+    `;
+  }
+  power(power) {
+    return power ? "(power)" : "";
+  }
+  pin_display_opt(opt) {
+    if (!opt) return;
+    const offset = (off) => off ? `(offset ${off})` : "";
+    const hide = (h) => h ? "hide" : "";
+    const pin_numbers = `${opt.pin_numbers ? `(pin_numbers ${offset(opt.pin_numbers.offset)}  ${hide(opt.pin_numbers.hide)})` : ""}`;
+    const pin_names = `${opt.pin_names ? `(pin_names ${offset(opt.pin_names.offset)}  ${hide(opt.pin_names.hide)})` : ""}`;
+    return `${pin_numbers}
+    ${pin_names}
+    `;
+  }
+  lib_symbol(lib_symbol) {
+    return `
+      (symbol "${lib_symbol.name}" ${this.power(lib_symbol.power)}
+      ${this.pin_display_opt(lib_symbol)}
+      ${this.booleans(lib_symbol)}
+      ${this.fields(lib_symbol.properties)}
+      ${this.pin_defs(lib_symbol.pins)}
+      ${this.drawings(lib_symbol.drawings)}
+      ${this.lib_children(lib_symbol.children)}
+)
+    `;
+  }
+  lib_children(libs) {
+    if (!libs) return "";
+    return libs.map((i) => this.lib_symbol(i)).join(SCOPE_END);
+  }
+  pts(points) {
+    return `(pts ${points.map((i) => `(xy ${i.x} ${i.y} )`).join(SPACE)})`;
+  }
+  drawings(draws) {
+    if (!draws) return;
+    return draws.map((i) => this.drawing(i)).join(SCOPE_END);
+  }
+  drawing(draw) {
+    if (!("shape" in draw)) throw new Error(`Unhandled drawing ${draw}`);
+    switch (draw.shape) {
+      case SHAPE_T.POLY:
+        return `(polyline
+          ${this.pts(draw.pts)}
+          ${this.stroke(draw.stroke)}
+          ${this.fill(draw.fill)}
+				)`;
+    }
+    throw new Error(`Unhandled drawing ${draw}`);
+  }
+  pin_defs(defs) {
+    if (!defs) return;
+    return defs.map((it) => this.pin_def(it)).join(SCOPE_END);
+  }
+  pin_def(def) {
+    return `(pin ${READABLE_ELECTRICAL_PINTYPE[def.type]} ${def.shape}
+					${this.at(def.at)}
+					(length ${def.length})
+					(name "${def.name.text}"
+            ${this.effects(def.name.effects)}
+					)
+					(number "${def.number.text}"
+            ${this.effects(def.number.effects)}
+					)
+				)`;
+  }
+  label(label) {
+    return `	(${label.label_type} "${label.text}"
+		${this.at(label.at)}
+    ${this.fields_autoplaced()}
+    ${this.effects(label.effects)}
+		${this.uuid(label.uuid)}
+	)`;
+  }
+  unit(c) {
+    return `(unit ${c})`;
+  }
+  sch_symbol(sch_symbol) {
+    return `(symbol
+		${this.lib_id(sch_symbol.lib_id)}
+		${this.at(sch_symbol.at)}
+		${this.unit(sch_symbol.unit)}
+    ${this.booleans(sch_symbol)}
+		${this.fields(sch_symbol.properties)}
+    ${sch_symbol.pins.map((pin) => this.sch_symbol_pin(pin)).join(SCOPE_START)}
+	)`;
+  }
+  wire(w) {
+    return `(wire
+      ${this.pts([w.start, w.end])}
+      ${this.stroke(w.stroke)}
+      ${this.uuid(w.uuid)}
+ )`;
+  }
+  lib_id(id) {
+    if (!id) return;
+    return `(lib_id "${id}")`;
+  }
+  sch_symbol_pin(pin) {
+    return `(pin "${pin.number}" ${this.uuid(pin.uuid)})`;
+  }
+  sch_sheet(sheet) {
+    return `(sheet 
+    ${this.at(sheet.at)}
+    ${this.size(sheet.size)}
+    ${this.fields_autoplaced()}
+    ${this.stroke(sheet.stroke)}
+    ${this.fill(sheet.fill)}
+    ${this.uuid(sheet.uuid)}
+    ${this.fields(sheet.fields)}
+    ${sheet.pins.map((sheet_pin) => this.sch_sheet_pin(sheet_pin)).join(SCOPE_START)}
+    )`;
+  }
+  sch_sheet_pin(sheet_pin) {
+    return `(pin "${sheet_pin.text}" ${sheet_pin.shape}
+			${this.at(sheet_pin.at)}
+            ${this.effects(sheet_pin.effects)}
+			${this.uuid(sheet_pin.uuid)}
+		)`;
+  }
+  at(pos) {
+    return `(at ${pos.position.x} ${pos.position.y} ${pos.rotation === void 0 ? "" : pos.rotation})`;
+  }
+  uuid(id) {
+    return `(uuid "${id}")`;
+  }
+  effects(e) {
+    return `(effects
+      (font
+        (size ${e.font.size.x} ${e.font.size.y})
+      )${this.justify(e.justify)}${e.hide ? "(hide yes)" : ""}
+    )`;
+  }
+  justify(justify) {
+    if (!justify) return;
+    return `(justify ${justify.horizontal} ${justify.vertical})`;
+  }
+  booleans(it) {
+    if (typeof it !== "object" || !it) return;
+    const res = [];
+    for (const [k, v] of Object.entries(it)) {
+      if (typeof v === "boolean" && !IGNORE_BOOLEANS.has(k)) res.push(`( ${k} ${v ? "yes" : "no"} )`);
+    }
+    return res.join(SCOPE_START);
+  }
+  fields(fields) {
+    if (!fields) return;
+    return fields.map((f) => this.field(f)).join(SCOPE_START);
+  }
+  field(field) {
+    return `(property "${field.name}" "${field.text}"
+			${this.at(field.at)}
+            ${this.effects(field.effects)}
+		)`;
+  }
+  fill(f) {
+    if (!f) return;
+    return `(fill${f.type ? ` (type ${f.type})` : ""} ${this.color(f.color)})`;
+  }
+  size(s) {
+    return `(size ${s.x} ${s.y})`;
+  }
+  fields_autoplaced() {
+    return "(fields_autoplaced yes)";
+  }
+  stroke(s) {
+    if (!s) return;
+    return `(stroke
+			(width ${s.width})
+			(type ${s.type})
+      ${this.color(s.color)}
+		)`;
+  }
+  color(c) {
+    if (!c) return;
+    return `(color ${c.r} ${c.g} ${c.b} ${c.a})`;
+  }
+};
+_init = __decoratorStart(null);
+__decorateElement(_init, 1, "power", _power_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "pin_display_opt", _pin_display_opt_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "lib_children", _lib_children_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "drawings", _drawings_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "pin_defs", _pin_defs_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "unit", _unit_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "lib_id", _lib_id_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "justify", _justify_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "fields", _fields_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "fill", _fill_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "stroke", _stroke_dec, SCHEMATIC_PRINTER);
+__decorateElement(_init, 1, "color", _color_dec, SCHEMATIC_PRINTER);
+__decoratorMetadata(_init, SCHEMATIC_PRINTER);
+
+// src/converter/graph_to_netlist/graph_converter.ts
+import {
+  ConnectionNodeType as ConnectionNodeType2
+} from "@modular-circuit/electronics-model";
+
+// src/converter/link_to_netlist/converter.ts
+import {
+  ConnectionNodeType,
+  LinkType,
+  gen_link_map,
+  get_port_link_type
+} from "@modular-circuit/electronics-model";
+
+// src/converter/link_to_netlist/links/converters.ts
+import {
+  PortType
+} from "@modular-circuit/electronics-model";
+
+// src/converter/link_to_netlist/links/converter_base.ts
+var LinkConverterBase = class {
+  constructor(ctx, ports, net_pros) {
+    this.ctx = ctx;
+    this.ports = ports;
+    this.net_pros = net_pros;
+  }
+  convert() {
+    if (!this.init_link()) return;
+    this.do_convert();
+  }
+  get_net_code() {
+    return this.ctx.nl_netlist.nets.length + 1;
+  }
+  gen_net_name(signal_name) {
+    const base_net_name = signal_name ? `${this.net_pros.name}-${signal_name}` : `${this.net_pros.name}`;
+    if (this.net_pros.is_global_pwr)
+      return base_net_name;
+    if (!this.ctx.net_names_count.has(base_net_name)) {
+      this.ctx.net_names_count.set(base_net_name, 0);
+      return base_net_name;
+    }
+    const count = this.ctx.net_names_count.get(base_net_name);
+    this.ctx.net_names_count.set(base_net_name, count + 1);
+    return `${base_net_name}-${count}`;
+  }
+};
+var MetaPortConverter = class extends LinkConverterBase {
+  do_convert() {
+    const pins = [];
+    for (const p of this.ports) {
+      const p_id = this.ctx.port_map.get(p);
+      pins.push(...Object.values(this.ctx.pin_map[p_id]));
+    }
+    this.ctx.nl_netlist.nets.push({
+      code: this.get_net_code(),
+      name: this.gen_net_name(),
+      pins
+    });
+  }
+  init_link() {
+    return true;
+  }
+};
+var CompositePortLinkConverterBase = class extends LinkConverterBase {
+  do_convert() {
+    for (const signal of this.get_signals()) {
+      const pins = [];
+      for (const port of signal.ports) {
+        pins.push(
+          this.ctx.pin_map[this.ctx.port_map.get(port.parent)][port.meta_port.label_associated]
+        );
+      }
+      this.ctx.nl_netlist.nets.push({
+        code: this.get_net_code(),
+        name: this.gen_net_name(signal.name),
+        pins
+      });
+    }
+  }
+};
+
+// src/converter/link_to_netlist/links/converters.ts
+var CanLogicLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    return [
+      {
+        name: "txd",
+        ports: [
+          {
+            parent: this.link.controller,
+            meta_port: this.link.controller.txd
+          },
+          {
+            parent: this.link.transceiver,
+            meta_port: this.link.transceiver.rxd
+          },
+          ...this.link.passive.map((port) => {
+            return {
+              parent: port,
+              meta_port: port.rxd
+            };
+          })
+        ]
+      },
+      {
+        name: "rxd",
+        ports: [
+          {
+            parent: this.link.controller,
+            meta_port: this.link.controller.rxd
+          },
+          {
+            parent: this.link.transceiver,
+            meta_port: this.link.transceiver.txd
+          },
+          ...this.link.passive.map((port) => {
+            return {
+              parent: port,
+              meta_port: port.txd
+            };
+          })
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const controllers = [];
+    const transceivers = [];
+    const passive = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case PortType.CanControllerPort: {
+          controllers.push(v);
+          break;
+        }
+        case PortType.CanTransceiverPort: {
+          transceivers.push(v);
+          break;
+        }
+        case PortType.CanPassivePort: {
+          passive.push(v);
+          break;
+        }
+      }
+    }
+    if (controllers.length !== 1) {
+      return false;
+    }
+    if (transceivers.length !== 1) {
+      return false;
+    }
+    this.link = {
+      controller: controllers[0],
+      transceiver: transceivers[0],
+      passive
+    };
+    return true;
+  }
+};
+var CanDiffLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    return [
+      {
+        name: "canh",
+        ports: [
+          ...this.link.nodes.map((port) => {
+            return {
+              parent: port,
+              meta_port: port.canh
+            };
+          })
+        ]
+      },
+      {
+        name: "canl",
+        ports: [
+          ...this.link.nodes.map((port) => {
+            return {
+              parent: port,
+              meta_port: port.canl
+            };
+          })
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const nodes = [];
+    for (const v of this.ports) {
+      if (v.type === PortType.CanDiffPort) {
+        nodes.push(v);
+      }
+    }
+    if (nodes.length === 0) {
+      return false;
+    }
+    this.link = {
+      nodes
+    };
+    return true;
+  }
+};
+var CrystalLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    const driver = this.link.driver;
+    const crystal = this.link.crystal;
+    return [
+      {
+        name: "xtal",
+        ports: [
+          {
+            parent: driver,
+            meta_port: driver.xtal_in
+          },
+          {
+            parent: crystal,
+            meta_port: crystal.xtal_out
+          }
+        ]
+      },
+      {
+        name: "xtal",
+        ports: [
+          {
+            parent: driver,
+            meta_port: driver.xtal_out
+          },
+          {
+            parent: crystal,
+            meta_port: crystal.xtal_in
+          }
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const drivers = [];
+    const crystals = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case PortType.CrystalDriver: {
+          drivers.push(v);
+          break;
+        }
+        case PortType.CrystalPort: {
+          crystals.push(v);
+          break;
+        }
+      }
+    }
+    if (drivers.length !== 1) {
+      return false;
+    }
+    if (crystals.length !== 1) {
+      return false;
+    }
+    this.link = {
+      driver: drivers[0],
+      crystal: crystals[0]
+    };
+    return true;
+  }
+};
+var SwdLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    return [
+      {
+        name: "swdio",
+        ports: [
+          {
+            parent: this.link.host,
+            meta_port: this.link.host.swdio
+          },
+          {
+            parent: this.link.device,
+            meta_port: this.link.device.swdio
+          },
+          ...this.link.pull.map((port) => {
+            return {
+              parent: port,
+              meta_port: port.swdio
+            };
+          })
+        ]
+      },
+      {
+        name: "swclk",
+        ports: [
+          {
+            parent: this.link.host,
+            meta_port: this.link.host.swclk
+          },
+          {
+            parent: this.link.device,
+            meta_port: this.link.device.swclk
+          },
+          ...this.link.pull.map((port) => {
+            return {
+              parent: port,
+              meta_port: port.swclk
+            };
+          })
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const hosts = [];
+    const devices = [];
+    const pull = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case PortType.SwdHostPort: {
+          hosts.push(v);
+          break;
+        }
+        case PortType.SwdTargetPort: {
+          devices.push(v);
+          break;
+        }
+        case PortType.SwdPullPort: {
+          pull.push(v);
+          break;
+        }
+      }
+    }
+    if (hosts.length !== 1) {
+      return false;
+    }
+    if (devices.length !== 1) {
+      return false;
+    }
+    this.link = {
+      host: hosts[0],
+      device: devices[0],
+      pull
+    };
+    return true;
+  }
+};
+var I2cLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    const scl = [
+      ...this.link.pull.map((device) => ({
+        parent: device,
+        meta_port: device.scl
+      })),
+      {
+        parent: this.link.controller,
+        meta_port: this.link.controller.scl
+      },
+      ...this.link.targets.map((device) => ({
+        parent: device,
+        meta_port: device.scl
+      }))
+    ];
+    const sda = [
+      ...this.link.pull.map((device) => ({
+        parent: device,
+        meta_port: device.sda
+      })),
+      {
+        parent: this.link.controller,
+        meta_port: this.link.controller.sda
+      },
+      ...this.link.targets.map((device) => ({
+        parent: device,
+        meta_port: device.sda
+      }))
+    ];
+    return [
+      {
+        name: "scl",
+        ports: scl
+      },
+      {
+        name: "sda",
+        ports: sda
+      }
+    ];
+  }
+  init_link() {
+    const pull = [];
+    const controllers = [];
+    const targets = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case PortType.I2cPullupPort: {
+          pull.push(v);
+          break;
+        }
+        case PortType.I2cController: {
+          controllers.push(v);
+          break;
+        }
+        case PortType.I2cTarget: {
+          targets.push(v);
+          break;
+        }
+      }
+    }
+    if (controllers.length !== 1) {
+      return false;
+    }
+    if (targets.length === 0) {
+      return false;
+    }
+    this.link = {
+      pull,
+      controller: controllers[0],
+      targets
+    };
+    return true;
+  }
+};
+var I2sLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    const controller = this.link.controller;
+    const target_receiver = this.link.target_receiver;
+    return [
+      {
+        name: "sck",
+        ports: [
+          {
+            parent: controller,
+            meta_port: controller.sck
+          },
+          {
+            parent: target_receiver,
+            meta_port: target_receiver.sck
+          }
+        ]
+      },
+      {
+        name: "ws",
+        ports: [
+          {
+            parent: controller,
+            meta_port: controller.ws
+          },
+          {
+            parent: target_receiver,
+            meta_port: target_receiver.ws
+          }
+        ]
+      },
+      {
+        name: "sd",
+        ports: [
+          {
+            parent: controller,
+            meta_port: controller.sd
+          },
+          {
+            parent: target_receiver,
+            meta_port: target_receiver.sd
+          }
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const controllers = [];
+    const target_receivers = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case PortType.I2sController: {
+          controllers.push(v);
+          break;
+        }
+        case PortType.I2sTargetReceiver: {
+          target_receivers.push(v);
+          break;
+        }
+      }
+    }
+    if (controllers.length !== 1) {
+      return false;
+    }
+    if (target_receivers.length !== 1) {
+      return false;
+    }
+    this.link = {
+      controller: controllers[0],
+      target_receiver: target_receivers[0]
+    };
+    return true;
+  }
+};
+var SpiLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    const controller = this.link.controller;
+    const peripherals = this.link.peripherals;
+    return [
+      {
+        name: "sck",
+        ports: [
+          {
+            parent: controller,
+            meta_port: controller.sck
+          },
+          ...peripherals.map((device) => ({
+            parent: device,
+            meta_port: device.sck
+          }))
+        ]
+      },
+      {
+        name: "miso",
+        ports: [
+          {
+            parent: controller,
+            meta_port: controller.miso
+          },
+          ...peripherals.map((device) => ({
+            parent: device,
+            meta_port: device.miso
+          }))
+        ]
+      },
+      {
+        name: "mosi",
+        ports: [
+          {
+            parent: controller,
+            meta_port: controller.mosi
+          },
+          ...peripherals.map((device) => ({
+            parent: device,
+            meta_port: device.mosi
+          }))
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const controllers = [];
+    const peripherals = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case PortType.SpiController: {
+          controllers.push(v);
+          break;
+        }
+        case PortType.SpiPeripheral: {
+          peripherals.push(v);
+          break;
+        }
+      }
+    }
+    if (controllers.length !== 1) {
+      return false;
+    }
+    if (peripherals.length === 0) {
+      return false;
+    }
+    this.link = {
+      controller: controllers[0],
+      peripherals
+    };
+    return true;
+  }
+};
+var SpeakerLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    return [
+      {
+        name: "a",
+        ports: [
+          {
+            parent: this.link.source,
+            meta_port: this.link.source.a
+          },
+          {
+            parent: this.link.sink,
+            meta_port: this.link.sink.a
+          }
+        ]
+      },
+      {
+        name: "b",
+        ports: [
+          {
+            parent: this.link.source,
+            meta_port: this.link.source.b
+          },
+          {
+            parent: this.link.sink,
+            meta_port: this.link.sink.b
+          }
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const sources = [];
+    const sinks = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case PortType.SpeakerDriverPort: {
+          sources.push(v);
+          break;
+        }
+        case PortType.SpeakerPort: {
+          sinks.push(v);
+          break;
+        }
+      }
+    }
+    if (sources.length !== 1) {
+      return false;
+    }
+    if (sinks.length !== 1) {
+      return false;
+    }
+    this.link = {
+      source: sources[0],
+      sink: sinks[0]
+    };
+    return true;
+  }
+};
+var UartLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    return [
+      {
+        name: "tx",
+        ports: [
+          {
+            parent: this.link.a,
+            meta_port: this.link.a.tx
+          },
+          {
+            parent: this.link.b,
+            meta_port: this.link.b.rx
+          }
+        ]
+      },
+      {
+        name: "rx",
+        ports: [
+          {
+            parent: this.link.b,
+            meta_port: this.link.b.tx
+          },
+          {
+            parent: this.link.a,
+            meta_port: this.link.a.rx
+          }
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const ports = [];
+    for (const v of this.ports) {
+      if (v.type === PortType.UartPort) {
+        ports.push(v);
+      }
+    }
+    if (ports.length !== 2) {
+      return false;
+    }
+    this.link = {
+      a: ports[0],
+      b: ports[1]
+    };
+    return true;
+  }
+};
+var UsbLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    return [
+      {
+        name: "dp",
+        ports: [
+          {
+            parent: this.link.host,
+            meta_port: this.link.host.dp
+          },
+          {
+            parent: this.link.device,
+            meta_port: this.link.device.dp
+          },
+          ...this.link.passive.map((port) => ({
+            parent: port,
+            meta_port: port.dp
+          }))
+        ]
+      },
+      {
+        name: "dm",
+        ports: [
+          {
+            parent: this.link.host,
+            meta_port: this.link.host.dm
+          },
+          {
+            parent: this.link.device,
+            meta_port: this.link.device.dm
+          },
+          ...this.link.passive.map((port) => ({
+            parent: port,
+            meta_port: port.dm
+          }))
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const hosts = [];
+    const devices = [];
+    const passive = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case PortType.UsbHostPort: {
+          hosts.push(v);
+          break;
+        }
+        case PortType.UsbDevicePort: {
+          devices.push(v);
+          break;
+        }
+        case PortType.UsbPassivePort: {
+          passive.push(v);
+          break;
+        }
+      }
+    }
+    if (hosts.length !== 1) {
+      return false;
+    }
+    if (devices.length !== 1) {
+      return false;
+    }
+    this.link = {
+      host: hosts[0],
+      device: devices[0],
+      passive
+    };
+    return true;
+  }
+};
+var UsbCcLinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    return [
+      {
+        name: "cc1",
+        ports: [
+          {
+            parent: this.link.a,
+            meta_port: this.link.a.cc1
+          },
+          {
+            parent: this.link.b,
+            meta_port: this.link.b.cc1
+          }
+        ]
+      },
+      {
+        name: "cc2",
+        ports: [
+          {
+            parent: this.link.a,
+            meta_port: this.link.a.cc2
+          },
+          {
+            parent: this.link.b,
+            meta_port: this.link.b.cc2
+          }
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const nodes = [];
+    for (const v of this.ports) {
+      if (v.type === PortType.UsbCcPort) {
+        nodes.push(v);
+      }
+    }
+    if (nodes.length !== 2) {
+      return false;
+    }
+    this.link = {
+      a: nodes[0],
+      b: nodes[1]
+    };
+    return true;
+  }
+};
+var Dvp8LinkTester = class extends CompositePortLinkConverterBase {
+  get_signals() {
+    if (!this.link) return [];
+    const host = this.link.host;
+    const cam = this.link.cam;
+    return [
+      {
+        name: "xclk",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.xclk
+          },
+          {
+            parent: cam,
+            meta_port: cam.xclk
+          }
+        ]
+      },
+      {
+        name: "pclk",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.pclk
+          },
+          {
+            parent: cam,
+            meta_port: cam.pclk
+          }
+        ]
+      },
+      {
+        name: "href",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.href
+          },
+          {
+            parent: cam,
+            meta_port: cam.href
+          }
+        ]
+      },
+      {
+        name: "vsync",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.vsync
+          },
+          {
+            parent: cam,
+            meta_port: cam.vsync
+          }
+        ]
+      },
+      {
+        name: "y0",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.y0
+          },
+          {
+            parent: cam,
+            meta_port: cam.y0
+          }
+        ]
+      },
+      {
+        name: "y1",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.y1
+          }
+        ]
+      },
+      {
+        name: "y2",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.y2
+          },
+          {
+            parent: cam,
+            meta_port: cam.y2
+          }
+        ]
+      },
+      {
+        name: "y3",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.y3
+          },
+          {
+            parent: cam,
+            meta_port: cam.y3
+          }
+        ]
+      },
+      {
+        name: "y4",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.y4
+          }
+        ]
+      },
+      {
+        name: "y5",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.y5
+          },
+          {
+            parent: cam,
+            meta_port: cam.y5
+          }
+        ]
+      },
+      {
+        name: "y6",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.y6
+          },
+          {
+            parent: cam,
+            meta_port: cam.y6
+          }
+        ]
+      },
+      {
+        name: "y7",
+        ports: [
+          {
+            parent: host,
+            meta_port: host.y7
+          },
+          {
+            parent: cam,
+            meta_port: cam.y7
+          }
+        ]
+      }
+    ];
+  }
+  init_link() {
+    const hosts = [];
+    const cams = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case PortType.Dvp8Host: {
+          hosts.push(v);
+          break;
+        }
+        case PortType.Dvp8Camera: {
+          cams.push(v);
+          break;
+        }
+      }
+    }
+    if (hosts.length !== 1) {
+      return false;
+    }
+    if (cams.length !== 1) {
+      return false;
+    }
+    this.link = {
+      host: hosts[0],
+      cam: cams[0]
+    };
+    return true;
+  }
+};
+
+// src/converter/link_to_netlist/converter.ts
+var LINK_CONVERTER = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  port_is_composite_port(p) {
+    return Object.values(this.ctx.pin_map[this.port_id.get(p)]).length > 1;
+  }
+  do_convert(CtorClass, ports, net_pros) {
+    return new CtorClass(this.ctx, ports, net_pros).convert();
+  }
+  visit_cc(cc) {
+    if (cc.is_isolated) {
+      return;
+    }
+    this.link_map = gen_link_map();
+    const ports = cc.nodes.filter((i) => i.type === ConnectionNodeType.Port);
+    const meta_ports = [];
+    this.port_id = /* @__PURE__ */ new Map();
+    for (const p of ports) this.port_id.set(p.param, p.uuid);
+    for (const v of ports) {
+      const port = v.param;
+      const arr = this.link_map[get_port_link_type(port)];
+      if (this.port_is_composite_port(port)) {
+        arr.push(port);
+      } else {
+        meta_ports.push(port);
+      }
+    }
+    const meta_port_converter = new MetaPortConverter(this.ctx, meta_ports, cc);
+    meta_port_converter.convert();
+    for (const [k, v] of Object.entries(this.link_map)) {
+      if (!v || !v.length) continue;
+      switch (k) {
+        case LinkType.CanLogicLink: {
+          this.do_convert(CanLogicLinkTester, v, cc);
+          break;
+        }
+        case LinkType.CanDiffLink: {
+          this.do_convert(CanDiffLinkTester, v, cc);
+          break;
+        }
+        case LinkType.CrystalLink: {
+          this.do_convert(CrystalLinkTester, v, cc);
+          break;
+        }
+        case LinkType.SwdLink: {
+          this.do_convert(SwdLinkTester, v, cc);
+          break;
+        }
+        case LinkType.I2cLink: {
+          this.do_convert(I2cLinkTester, v, cc);
+          break;
+        }
+        case LinkType.I2sLink: {
+          this.do_convert(I2sLinkTester, v, cc);
+          break;
+        }
+        case LinkType.SpiLink: {
+          this.do_convert(SpiLinkTester, v, cc);
+          break;
+        }
+        case LinkType.SpeakerLink: {
+          this.do_convert(SpeakerLinkTester, v, cc);
+          break;
+        }
+        case LinkType.UartLink: {
+          this.do_convert(UartLinkTester, v, cc);
+          break;
+        }
+        case LinkType.UsbLink: {
+          this.do_convert(UsbLinkTester, v, cc);
+          break;
+        }
+        case LinkType.UsbCcLink: {
+          this.do_convert(UsbCcLinkTester, v, cc);
+          break;
+        }
+        case LinkType.Dvp8Link: {
+          this.do_convert(Dvp8LinkTester, v, cc);
+          break;
+        }
+        default: {
+          throw new Error(`Unhandled link type: ${k}`);
+        }
+      }
+    }
+  }
+};
+
+// src/converter/graph_to_netlist/graph_converter.ts
+var GraphConverter = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  convert_to_netlist() {
+    let pin_count = 0;
+    const nl_netlist = {
+      nets: [],
+      schematics: {}
+    };
+    const pin_map = {};
+    const port_map = /* @__PURE__ */ new Map();
+    const pin_shapes = {};
+    for (const sub of this.ctx.connection_graph.subgraphs) {
+      for (const node of sub.nodes) {
+        if (node.type === ConnectionNodeType2.Port) {
+          const port_id = node.uuid;
+          port_map.set(node.param, port_id);
+          for (const [label_name, shape] of Object.entries(node.label_shapes)) {
+            const pin_id = `pin-${++pin_count}`;
+            pin_shapes[pin_id] = shape;
+            if (!(port_id in pin_map)) {
+              pin_map[port_id] = {};
+            }
+            pin_map[port_id][label_name] = pin_id;
+          }
+        }
+      }
+    }
+    for (const [filename, sch] of Object.entries(this.ctx.cg_schematics)) {
+      const { uuid, powers, sheets } = sch;
+      const sheet_symbols = [];
+      for (const sheet of sheets) {
+        const pins = [];
+        for (const port_id of sheet.ports) {
+          if (!(port_id in pin_map)) {
+            console.error(`Port ${port_id} not found in pin_map`);
+            continue;
+          }
+          for (const [label_name, pin_id] of Object.entries(pin_map[port_id])) {
+            pins.push({
+              uuid: pin_id,
+              name: label_name,
+              shape: pin_shapes[pin_id]
+            });
+          }
+        }
+        sheet_symbols.push({ ...sheet, pins });
+      }
+      nl_netlist.schematics[filename] = {
+        uuid,
+        filename,
+        powers,
+        sheet_symbols,
+        hiera_labels: []
+      };
+    }
+    const link_converter = new LINK_CONVERTER({
+      pin_map,
+      nl_netlist,
+      port_map,
+      net_names_count: /* @__PURE__ */ new Map()
+    });
+    for (const sub of this.ctx.connection_graph.subgraphs) {
+      link_converter.visit_cc(sub);
+    }
+    return nl_netlist;
+  }
+};
+
+// src/converter/netlist_to_kicad/layout.ts
+import ELK from "elkjs/lib/elk.bundled.js";
+var MIL_TO_MM = 0.0254;
+var GRID_SIZE = 50 * MIL_TO_MM;
+var FONT_SIZE = GRID_SIZE;
+var POWER_START_Y = 30 * GRID_SIZE;
+var POWER_START_X = (PAPER_SIZE.A4.height - 30) * GRID_SIZE;
+var POWER_Y_STEP = 16 * GRID_SIZE;
+var BLOCK_V_SPACE = 8 * GRID_SIZE;
+var BLOCK_H_SPACE = 14 * GRID_SIZE - BLOCK_V_SPACE;
+var PADDING = 10 * GRID_SIZE;
+var PADDING_TOP = 21 * GRID_SIZE;
+function get_power_pos(pwr_number) {
+  return { x: POWER_START_X, y: POWER_START_Y + POWER_Y_STEP * pwr_number };
+}
+var BLOCK_PIN_GAP = 4 * GRID_SIZE;
+var BLOCK_PIN_TB_MARGIN = 2 * GRID_SIZE;
+var MIN_BLOCK_WIDTH = 8 * GRID_SIZE;
+var INTERNAL_LABEL_MARGIN = 8 * FONT_SIZE;
+var WIRE_PADDING = GRID_SIZE;
+var SIDE_MARGIN = WIRE_PADDING * 2 + BLOCK_H_SPACE / 2;
+var Layout = class {
+  constructor() {
+    this.block_geo = {};
+    this.elk = new ELK();
+  }
+  add_block(id, factor) {
+    this.block_geo[id] = this.calc_block_size(factor);
+  }
+  async finalize() {
+    const bbox = {};
+    const graph = {
+      id: "root",
+      layoutOptions: {
+        "elk.algorithm": "rectpacking",
+        "elk.contentAlignment": "V_TOP | H_LEFT",
+        "elk.rectpacking.orderBySize": "true",
+        "elk.nodeSize.fixedGraphSize": "true",
+        "org.eclipse.elk.rectpacking.packing.compaction.rowHeightReevaluation": "true",
+        "elk.rectpacking.widthApproximation.optimizationGoal": "ASPECT_RATIO_DRIVEN",
+        "org.eclipse.elk.rectpacking.packing.compaction.iterations": "5",
+        "org.eclipse.elk.aspectRatio": "1.414",
+        "elk.spacing.nodeNode": `${BLOCK_V_SPACE}`,
+        "elk.padding": `[top=${PADDING_TOP},left=${PADDING},bottom=${PADDING},right=${PADDING}]`,
+        "elk.childAreaWidth": `${PAPER_SIZE.A4.height}`,
+        "elk.childAreaHeight": `${PAPER_SIZE.A4.width}`
+      },
+      children: [],
+      edges: []
+    };
+    for (const [id, geo] of Object.entries(this.block_geo)) {
+      const bounding_size = geo.bounding_size;
+      graph.children.push({
+        id,
+        width: bounding_size.x,
+        height: bounding_size.y
+      });
+    }
+    const res = await this.elk.layout(graph);
+    if (res.children) {
+      for (const child of res.children) {
+        const geo = this.block_geo[child.id];
+        const pos = {
+          x: (child.x ?? 0) + geo.l_margin,
+          y: child.y ?? 0
+        };
+        bbox[child.id] = {
+          pos,
+          size: geo.size
+        };
+      }
+    }
+    return bbox;
+  }
+  calc_block_size(factor) {
+    const block_height = Math.floor(factor.total_pin_num / 2) * BLOCK_PIN_GAP + 2 * BLOCK_PIN_TB_MARGIN;
+    const block_width = Math.max(
+      MIN_BLOCK_WIDTH,
+      factor.internal.l_side + factor.internal.r_side + INTERNAL_LABEL_MARGIN
+    );
+    const l_margin = factor.outer.l_side + SIDE_MARGIN;
+    const r_margin = factor.outer.r_side + SIDE_MARGIN;
+    const block_bounding_width = block_width + l_margin + r_margin;
+    const size = {
+      x: block_width,
+      y: block_height
+    };
+    const bounding_size = {
+      x: block_bounding_width,
+      y: block_height
+    };
+    return {
+      size,
+      bounding_size,
+      l_margin,
+      r_margin,
+      factor
+    };
+  }
+};
+
+// src/converter/netlist_to_kicad/netlist_converter.ts
+import { PowerShape } from "@modular-circuit/electronics-model";
+import {
+  MODULAR_CIRCUIT_SCH_EXT
+} from "@modular-circuit/ir";
+import { replaceAll } from "@modular-circuit/utils";
+
+// src/kicad/label/net_label.ts
+import { gen_uuid as gen_uuid2 } from "@modular-circuit/utils";
+
+// src/kicad/constraints/index.ts
+var DEFAULT_FONT_SIZE = {
+  x: 1.27,
+  y: 1.27
+};
+
+// src/kicad/label/net_label.ts
+var gen_net_label = (name, at, justify) => ({
+  label_type: "label",
+  text: name,
+  fields: [],
+  fields_autoplaced: true,
+  at: { position: at, rotation: 0 },
+  effects: {
+    font: { size: DEFAULT_FONT_SIZE },
+    justify
+  },
+  uuid: gen_uuid2()
+});
+
+// src/kicad/label/sheet_pin.ts
+import { gen_uuid as gen_uuid3 } from "@modular-circuit/utils";
+var gen_base_hierarchical_label = (text, at, justify, rotation, shape) => ({
+  shape,
+  effects: {
+    font: { size: DEFAULT_FONT_SIZE },
+    justify
+  },
+  text,
+  at: { position: at, rotation },
+  uuid: gen_uuid3()
+});
+var gen_sheet_pin = (text, at, justify, rotation, shape) => ({
+  label_type: "hierarchical_label",
+  ...gen_base_hierarchical_label(text, at, justify, rotation, shape)
+});
+var gen_hierarchical_label = gen_sheet_pin;
+
+// src/kicad/sheet/sheet.ts
+import { gen_uuid as gen_uuid4 } from "@modular-circuit/utils";
+var TEXT_MARGIN = 0.7116;
+var gen_sch_sheet = (rect, pins, fields) => ({
+  // NOTE no rotation in the sheet
+  at: { position: rect.pos },
+  size: rect.size,
+  pins,
+  fields: [
+    {
+      name: "Sheetname",
+      text: fields.Sheetname,
+      at: { position: { x: rect.pos.x, y: rect.pos.y - TEXT_MARGIN }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        justify: {
+          vertical: "bottom",
+          horizontal: "left"
+        }
+      }
+    },
+    {
+      name: "Sheetfile",
+      text: fields.Sheetfile,
+      at: { position: { x: rect.pos.x, y: rect.pos.y + rect.size.y + TEXT_MARGIN }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        justify: {
+          vertical: "top",
+          horizontal: "left"
+        }
+      }
+    }
+  ],
+  fields_autoplaced: true,
+  stroke: {
+    width: 0.1524,
+    type: "solid"
+  },
+  fill: {
+    color: { r: 0, g: 0, b: 0, a: 0 }
+  },
+  uuid: gen_uuid4()
+});
+
+// src/kicad/symbols/lib_symbol/gnd.ts
+import { ELECTRICAL_PINTYPE, GRAPHIC_PINSHAPE } from "@modular-circuit/electronics-model";
+import { SHAPE_T as SHAPE_T2 } from "@modular-circuit/ir";
+var gen_lib_gnd = (value) => ({
+  name: `power:${value}`,
+  pin_numbers: {
+    offset: 0,
+    hide: true
+  },
+  pin_names: {
+    offset: 0,
+    hide: true
+  },
+  in_bom: true,
+  on_board: true,
+  exclude_from_sim: false,
+  properties: [
+    {
+      name: "Reference",
+      text: "#PWR",
+      at: { position: { x: 0, y: -6.35 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Value",
+      text: `${value}`,
+      at: { position: { x: 0, y: -3.81 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE }
+      }
+    },
+    {
+      name: "Footprint",
+      text: "",
+      at: { position: { x: 0, y: 0 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Datasheet",
+      text: "",
+      at: { position: { x: 0, y: 0 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Description",
+      text: 'Power symbol creates a global label with name \\"GND\\" , ground',
+      at: { position: { x: 0, y: 0 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "ki_keywords",
+      text: "global power",
+      at: { position: { x: 0, y: 0 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    }
+  ],
+  children: [
+    {
+      name: `${value}_0_1`,
+      drawings: [
+        {
+          shape: SHAPE_T2.POLY,
+          pts: [
+            { x: 0, y: 0 },
+            { x: 0, y: -1.27 },
+            { x: 1.27, y: -1.27 },
+            { x: 0, y: -2.54 },
+            { x: -1.27, y: -1.27 },
+            { x: 0, y: -1.27 }
+          ],
+          stroke: {
+            width: 0,
+            type: "default"
+          },
+          fill: {
+            type: "none"
+          }
+        }
+      ]
+    },
+    {
+      name: `${value}_0_1`,
+      pins: [
+        {
+          type: ELECTRICAL_PINTYPE.PT_POWER_IN,
+          shape: GRAPHIC_PINSHAPE.LINE,
+          hide: false,
+          at: { position: { x: 0, y: 0 }, rotation: 270 },
+          length: 0,
+          name: {
+            text: "~",
+            effects: {
+              font: { size: DEFAULT_FONT_SIZE }
+            }
+          },
+          number: {
+            text: "1",
+            effects: {
+              font: { size: DEFAULT_FONT_SIZE }
+            }
+          }
+        }
+      ]
+    }
+  ]
+});
+
+// src/kicad/symbols/lib_symbol/vcc.ts
+import { ELECTRICAL_PINTYPE as ELECTRICAL_PINTYPE2, GRAPHIC_PINSHAPE as GRAPHIC_PINSHAPE2 } from "@modular-circuit/electronics-model";
+import { SHAPE_T as SHAPE_T3 } from "@modular-circuit/ir";
+var gen_lib_vcc = (value) => ({
+  name: `power:${value}`,
+  power: true,
+  pin_numbers: {
+    offset: 0,
+    hide: true
+  },
+  pin_names: {
+    offset: 0,
+    hide: true
+  },
+  in_bom: true,
+  on_board: true,
+  exclude_from_sim: false,
+  properties: [
+    {
+      name: "Reference",
+      text: "#PWR",
+      at: { position: { x: 0, y: -3.81 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Value",
+      text: `${value}`,
+      at: { position: { x: 0, y: 3.556 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE }
+      }
+    },
+    {
+      name: "Footprint",
+      text: "",
+      at: { position: { x: 0, y: 0 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Datasheet",
+      text: "",
+      at: { position: { x: 0, y: 0 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Description",
+      text: `Power symbol creates a global label with name \\"${value}\\"`,
+      at: { position: { x: 0, y: 0 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "ki_keywords",
+      text: "global power",
+      at: { position: { x: 0, y: 0 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    }
+  ],
+  children: [
+    {
+      name: `${value}_0_1`,
+      drawings: [
+        {
+          shape: SHAPE_T3.POLY,
+          pts: [
+            { x: -0.762, y: 1.27 },
+            { x: 0, y: 2.54 },
+            { x: 0.762, y: 1.27 }
+          ],
+          stroke: {
+            width: 0,
+            type: "default"
+          },
+          fill: {
+            type: "none"
+          }
+        }
+      ]
+    },
+    {
+      name: `${value}_1_1`,
+      pins: [
+        {
+          type: ELECTRICAL_PINTYPE2.PT_POWER_IN,
+          shape: GRAPHIC_PINSHAPE2.LINE,
+          hide: false,
+          at: { position: { x: 0, y: 0 }, rotation: 90 },
+          length: 0,
+          name: {
+            text: "~",
+            effects: {
+              font: { size: DEFAULT_FONT_SIZE }
+            }
+          },
+          number: {
+            text: "1",
+            effects: {
+              font: { size: DEFAULT_FONT_SIZE }
+            }
+          }
+        }
+      ]
+    }
+  ]
+});
+
+// src/kicad/symbols/sch_symbol/gnd.ts
+import { gen_uuid as gen_uuid5 } from "@modular-circuit/utils";
+
+// src/kicad/symbols/symbol_utils.ts
+var gen_pwr_ref = (pwr_num) => `#PWR${pwr_num}`;
+
+// src/kicad/symbols/sch_symbol/gnd.ts
+var gen_sch_gnd = (value, pwr_number, port_id, position) => ({
+  lib_id: `power:${value}`,
+  at: { position, rotation: 0 },
+  unit: 1,
+  exclude_from_sim: false,
+  in_bom: true,
+  on_board: true,
+  dnp: false,
+  fields_autoplaced: true,
+  uuid: gen_uuid5(),
+  properties: [
+    {
+      name: "Reference",
+      text: gen_pwr_ref(pwr_number),
+      at: { position: { x: position.x, y: position.y + 6.35 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Value",
+      text: `${value}`,
+      at: { position: { x: position.x, y: position.y + 5.08 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE }
+      }
+    },
+    {
+      name: "Footprint",
+      text: "",
+      at: { position, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Datasheet",
+      text: "",
+      at: { position, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Description",
+      text: `Power symbol creates a global label with name \\"${value}\\" , ground`,
+      at: { position, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    }
+  ],
+  pins: [
+    {
+      uuid: port_id,
+      number: "1"
+    }
+  ]
+});
+
+// src/kicad/symbols/sch_symbol/vcc.ts
+import { gen_uuid as gen_uuid6 } from "@modular-circuit/utils";
+var gen_sch_vcc = (value, pwr_number, port_id, position) => ({
+  lib_id: `power:${value}`,
+  at: { position, rotation: 0 },
+  unit: 1,
+  exclude_from_sim: false,
+  in_bom: true,
+  on_board: true,
+  dnp: false,
+  fields_autoplaced: true,
+  uuid: gen_uuid6(),
+  properties: [
+    {
+      name: "Reference",
+      text: gen_pwr_ref(pwr_number),
+      at: { position: { x: position.x, y: position.y + 3.81 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Value",
+      text: `${value}`,
+      at: { position: { x: position.x, y: position.y - 5.08 }, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE }
+      }
+    },
+    {
+      name: "Footprint",
+      text: "",
+      at: { position, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Datasheet",
+      text: "",
+      at: { position, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    },
+    {
+      name: "Description",
+      text: `Power symbol creates a global label with name \\"${value}\\"`,
+      at: { position, rotation: 0 },
+      effects: {
+        font: { size: DEFAULT_FONT_SIZE },
+        hide: true
+      }
+    }
+  ],
+  pins: [
+    {
+      number: "1",
+      uuid: port_id
+    }
+  ]
+});
+
+// src/kicad/wire/gen_wire.ts
+import { GS_SCH_ITEM_TYPE } from "@modular-circuit/electronics-model";
+import { gen_uuid as gen_uuid7 } from "@modular-circuit/utils";
+var gen_wire = (start, end) => ({
+  stroke: {
+    type: "default",
+    width: 0
+  },
+  start,
+  end,
+  uuid: gen_uuid7(),
+  type: GS_SCH_ITEM_TYPE.LINE
+});
+
+// src/converter/netlist_to_kicad/netlist_converter.ts
+var H_LABEL_FACTOR = {
+  internal: { l_side: 0, r_side: 0 },
+  outer: { l_side: 0, r_side: 0 },
+  total_pin_num: 1
+};
+var NetListConverter = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.sheet_pwr_count = 0;
+    this.net_name = {};
+    this.wires = [];
+    for (const net of this.ctx.netlist.nets) {
+      for (const it of net.pins) {
+        this.net_name[it] = net.name;
+      }
+    }
+  }
+  pin_is_connected(id) {
+    return this.net_name[id] !== void 0;
+  }
+  get_pin_net_name(id) {
+    return this.net_name[id];
+  }
+  async convert_to_kicad() {
+    const all_sch = {};
+    for (const [k, v] of Object.entries(this.ctx.netlist.schematics)) {
+      this.sheet_pwr_count = 0;
+      this.block_calc = new Layout();
+      all_sch[k] = await this.convert_sch(k, v);
+    }
+    return all_sch;
+  }
+  /**
+   * Convert a schematic to a kicad schematic
+   * @param name The name of the graph ,also the file name of the converted schematic
+   * @param schematic For net label , it will be reflected by the net name,
+   * no need to handle them before the other types of label are introduced, e.g. global or hierarchical
+   * @returns
+   */
+  async convert_sch(name, schematic) {
+    const powers = /* @__PURE__ */ new Set();
+    this.wires = [];
+    const sch = {
+      version: SCH_VERSION,
+      generator: GENERATOR_NAME,
+      generator_version: GENERATOR_VERSION,
+      paper: {
+        size: "A4"
+      },
+      title_block: {
+        title: name.replace(`.${MODULAR_CIRCUIT_SCH_EXT}`, ""),
+        date: replaceAll((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), "-", "/"),
+        rev: "1.0",
+        comment: {
+          1: "https://www.eda.cn",
+          2: this.ctx.project.author,
+          3: this.ctx.project.name
+        }
+      },
+      lib_symbols: {
+        symbols: []
+      },
+      uuid: schematic.uuid,
+      symbols: [],
+      labels: [],
+      sheets: []
+    };
+    for (const it of schematic.powers) {
+      if (!powers.has(it.value)) {
+        switch (it.shape) {
+          case PowerShape.VCC:
+            sch.lib_symbols?.symbols.push(gen_lib_vcc(it.value));
+            break;
+          case PowerShape.GND:
+            sch.lib_symbols?.symbols.push(gen_lib_gnd(it.value));
+            break;
+        }
+        powers.add(it.value);
+        this.convert_pwr_symbol(it, get_power_pos(this.sheet_pwr_count++), sch);
+      }
+    }
+    const sheet_names_count = /* @__PURE__ */ new Map();
+    const ordered_sheets = schematic.sheet_symbols.sort((a, b) => {
+      return b.pins.length - a.pins.length;
+    });
+    for (const it of ordered_sheets) {
+      const sheet_padding = this.get_sheet_symbol_lb_padding(it);
+      this.block_calc.add_block(it.uuid, sheet_padding);
+    }
+    for (const it of schematic.hiera_labels) {
+      this.block_calc.add_block(it.uuid, H_LABEL_FACTOR);
+    }
+    const res = await this.block_calc.finalize();
+    for (const it of ordered_sheets) {
+      this.convert_sheet_symbol(it, res[it.uuid], sch, sheet_names_count);
+    }
+    for (const it of schematic.hiera_labels) {
+      this.convert_hierarchical_label(it, res[it.uuid], sch);
+    }
+    sch.wires = this.wires;
+    return sch;
+  }
+  convert_hierarchical_label(pin, bbox, sch) {
+    sch.labels?.push(
+      gen_hierarchical_label(pin.name, bbox.pos, { horizontal: "left", vertical: "bottom" }, 0, pin.shape)
+    );
+  }
+  convert_pwr_symbol(pwr, at, sch) {
+    const pin_id = pwr.uuid;
+    const sch_pwr_symbol = pwr.shape === PowerShape.VCC ? gen_sch_vcc(pwr.value, this.sheet_pwr_count, pin_id, at) : gen_sch_gnd(pwr.value, this.sheet_pwr_count, pin_id, at);
+    sch.symbols.push(sch_pwr_symbol);
+    this.convert_net_label(pwr.value, at, sch);
+  }
+  get_sheet_symbol_lb_padding(sheet_sym) {
+    const factor = {
+      internal: {
+        l_side: 0,
+        r_side: 0
+      },
+      outer: {
+        l_side: 0,
+        r_side: 0
+      },
+      total_pin_num: sheet_sym.pins.length
+    };
+    const port_count = sheet_sym.pins.length;
+    const h_count = Math.ceil(port_count / 2);
+    for (let i = 0; i < port_count; i++) {
+      const is_left = i < h_count;
+      const cur_pin = sheet_sym.pins[i];
+      if (is_left) {
+        factor.internal.l_side = Math.max(factor.internal.l_side, cur_pin.name.length);
+      } else {
+        factor.internal.r_side = Math.max(factor.internal.r_side, cur_pin.name.length);
+      }
+      if (this.pin_is_connected(cur_pin.uuid)) {
+        const net_name = this.get_pin_net_name(cur_pin.uuid);
+        if (is_left) {
+          factor.outer.l_side = Math.max(factor.outer.l_side, net_name.length);
+        } else {
+          factor.outer.r_side = Math.max(factor.outer.r_side, net_name.length);
+        }
+      }
+    }
+    return {
+      internal: {
+        l_side: factor.internal.l_side * FONT_SIZE,
+        r_side: factor.internal.r_side * FONT_SIZE
+      },
+      outer: {
+        l_side: factor.outer.l_side * FONT_SIZE,
+        r_side: factor.outer.r_side * FONT_SIZE
+      },
+      total_pin_num: sheet_sym.pins.length
+    };
+  }
+  convert_sheet_symbol(sheet_sym, rect, sch, sheet_names_count) {
+    const port_count = sheet_sym.pins.length;
+    const pins = [];
+    const h_count = Math.floor(port_count / 2);
+    for (let i = 0; i < port_count; i++) {
+      const is_left = i < h_count;
+      const x = is_left ? rect.pos.x : rect.pos.x + rect.size.x;
+      const y = rect.pos.y + BLOCK_PIN_GAP * Math.abs(i < h_count ? i : i - h_count) + BLOCK_PIN_TB_MARGIN;
+      const justify = is_left ? "left" : "right";
+      const rotation = is_left ? 180 : 0;
+      pins.push(this.convert_sheet_pin(sheet_sym.pins[i], { x, y }, sch, justify, rotation, is_left));
+    }
+    let sheet_name = sheet_sym.sheet_name;
+    if (sheet_names_count.has(sheet_name)) {
+      const count = sheet_names_count.get(sheet_name);
+      sheet_name += `_${count}`;
+      sheet_names_count.set(sheet_name, count + 1);
+    } else {
+      sheet_names_count.set(sheet_name, 1);
+    }
+    sch.sheets.push(
+      gen_sch_sheet(rect, pins, {
+        Sheetfile: sheet_sym.sheet_file_name,
+        Sheetname: sheet_name
+      })
+    );
+  }
+  convert_sheet_pin(pin, pin_pos, sch, horizontal, rotation, is_left) {
+    if (this.pin_is_connected(pin.uuid)) {
+      const nt_name = this.get_pin_net_name(pin.uuid);
+      this.convert_net_label(
+        nt_name,
+        {
+          x: pin_pos.x + (is_left ? -WIRE_PADDING : WIRE_PADDING),
+          y: pin_pos.y
+        },
+        sch,
+        horizontal === "left" ? "right" : "left"
+      );
+      const lb_txt_len = nt_name.length * FONT_SIZE;
+      const wire_padding = lb_txt_len + 2 * WIRE_PADDING;
+      this.wires.push(
+        gen_wire(pin_pos, {
+          x: pin_pos.x + (is_left ? -wire_padding : wire_padding),
+          y: pin_pos.y
+        })
+      );
+    }
+    return gen_sheet_pin(pin.name, pin_pos, { horizontal, vertical: "bottom" }, rotation, pin.shape);
+  }
+  convert_net_label(net_name, pin_pos, sch, horizontal = "right") {
+    sch.labels.push(gen_net_label(net_name, pin_pos, { horizontal, vertical: "bottom" }));
+  }
+};
+
+// src/builder/graph_to_kicad/index.ts
+import { build_connection_graph } from "@modular-circuit/perc";
+
+// src/builder/graph_to_kicad/do_convert_graph_to_kicad_project.ts
+import { MODULAR_CIRCUIT_SCH_EXT as MODULAR_CIRCUIT_SCH_EXT2 } from "@modular-circuit/ir";
+
+// src/kicad/project/wildcards_and_files_ext.ts
+var KiCadSymbolLibFileExtension = "kicad_sym";
+var SchematicSymbolFileExtension = "sym";
+var LegacySymbolLibFileExtension = "lib";
+var LegacySymbolDocumentFileExtension = "dcm";
+var VrmlFileExtension = "wrl";
+var ProjectFileExtension = "kicad_pro";
+var LegacyProjectFileExtension = "pro";
+var ProjectLocalSettingsFileExtension = "kicad_prl";
+var LegacySchematicFileExtension = "sch";
+var CadstarSchematicFileExtension = "csa";
+var CadstarPartsLibraryFileExtension = "lib";
+var KiCadSchematicFileExtension = "kicad_sch";
+var SpiceFileExtension = "cir";
+var CadstarNetlistFileExtension = "frp";
+var OrCadPcb2NetlistFileExtension = "net";
+var NetlistFileExtension = "net";
+var AllegroNetlistFileExtension = "txt";
+var FootprintAssignmentFileExtension = "cmp";
+var GerberFileExtension = "gbr";
+var GerberJobFileExtension = "gbrjob";
+var HtmlFileExtension = "html";
+var EquFileExtension = "equ";
+var HotkeyFileExtension = "hotkeys";
+var DatabaseLibraryFileExtension = "kicad_dbl";
+var HTTPLibraryFileExtension = "kicad_httplib";
+var ArchiveFileExtension = "zip";
+var LegacyPcbFileExtension = "brd";
+var EaglePcbFileExtension = "brd";
+var CadstarPcbFileExtension = "cpa";
+var KiCadPcbFileExtension = "kicad_pcb";
+var DrawingSheetFileExtension = "kicad_wks";
+var DesignRulesFileExtension = "kicad_dru";
+var PdfFileExtension = "pdf";
+var MacrosFileExtension = "mcr";
+var DrillFileExtension = "drl";
+var SVGFileExtension = "svg";
+var ReportFileExtension = "rpt";
+var FootprintPlaceFileExtension = "pos";
+var KiCadFootprintLibPathExtension = "pretty";
+var LegacyFootprintLibPathExtension = "mod";
+var AltiumFootprintLibPathExtension = "PcbLib";
+var CadstarFootprintLibPathExtension = "cpa";
+var EagleFootprintLibPathExtension = "lbr";
+var GedaPcbFootprintLibFileExtension = "fp";
+var KiCadFootprintFileExtension = "kicad_mod";
+var SpecctraDsnFileExtension = "dsn";
+var SpecctraSessionFileExtension = "ses";
+var IpcD356FileExtension = "d356";
+var Ipc2581FileExtension = "xml";
+var WorkbookFileExtension = "wbk";
+var PngFileExtension = "png";
+var JpegFileExtension = "jpg";
+var TextFileExtension = "txt";
+var MarkdownFileExtension = "md";
+var CsvFileExtension = "csv";
+var XmlFileExtension = "xml";
+var JsonFileExtension = "json";
+var StepFileExtension = "step";
+var StepFileAbrvExtension = "stp";
+var GltfBinaryFileExtension = "glb";
+var GerberFileExtensionsRegex = /(gbr|gko|pho|(g[tb][alops])|(gm?\\d\\d*)|(gp[tb]))/;
+
+// src/kicad/project/kicad_project_archive.ts
+import { zipFiles } from "@modular-circuit/utils";
+
+// src/kicad/project/kicad_prl.ts
+var kicad_prl = (prj_name) => ({
+  board: {
+    active_layer: 0,
+    active_layer_preset: "",
+    auto_track_width: true,
+    hidden_netclasses: [],
+    hidden_nets: [],
+    high_contrast_mode: 0,
+    net_color_mode: 1,
+    opacity: {
+      images: 0.6,
+      pads: 1,
+      tracks: 1,
+      vias: 1,
+      zones: 0.6
+    },
+    selection_filter: {
+      dimensions: true,
+      footprints: true,
+      graphics: true,
+      keepouts: true,
+      lockedItems: false,
+      otherItems: true,
+      pads: true,
+      text: true,
+      tracks: true,
+      vias: true,
+      zones: true
+    },
+    visible_items: [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      26,
+      27,
+      28,
+      29,
+      30,
+      32,
+      33,
+      34,
+      35,
+      36,
+      39,
+      40
+    ],
+    visible_layers: "fffffff_ffffffff",
+    zone_display_mode: 0
+  },
+  git: {
+    repo_password: "",
+    repo_type: "",
+    repo_username: "",
+    ssh_key: ""
+  },
+  meta: {
+    filename: `${prj_name}.kicad_prl`,
+    version: 3
+  },
+  project: {
+    files: []
+  }
+});
+
+// src/kicad/project/kicad_pro.ts
+var kicad_pro = (project_name) => ({
+  board: {
+    "3dviewports": [],
+    ipc2581: {
+      dist: "",
+      distpn: "",
+      internal_id: "",
+      mfg: "",
+      mpn: ""
+    },
+    layer_presets: [],
+    viewports: []
+  },
+  boards: [],
+  cvpcb: {
+    equivalence_files: []
+  },
+  erc: {
+    erc_exclusions: [],
+    meta: {
+      version: 0
+    },
+    pin_map: [
+      [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2],
+      [0, 2, 0, 1, 0, 0, 1, 0, 2, 2, 2, 2],
+      [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 2],
+      [0, 1, 0, 0, 0, 0, 1, 1, 2, 1, 1, 2],
+      [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2],
+      [1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2],
+      [0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 2],
+      [0, 2, 1, 2, 0, 0, 1, 0, 2, 2, 2, 2],
+      [0, 2, 0, 1, 0, 0, 1, 0, 2, 0, 0, 2],
+      [0, 2, 1, 1, 0, 0, 1, 0, 2, 0, 0, 2],
+      [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+    ],
+    rule_severities: {
+      bus_definition_conflict: "error",
+      bus_entry_needed: "error",
+      bus_to_bus_conflict: "error",
+      bus_to_net_conflict: "error",
+      conflicting_netclasses: "error",
+      different_unit_footprint: "error",
+      different_unit_net: "error",
+      duplicate_reference: "error",
+      duplicate_sheet_names: "error",
+      endpoint_off_grid: "warning",
+      extra_units: "error",
+      global_label_dangling: "warning",
+      hier_label_mismatch: "error",
+      label_dangling: "error",
+      lib_symbol_issues: "warning",
+      missing_bidi_pin: "warning",
+      missing_input_pin: "warning",
+      missing_power_pin: "error",
+      missing_unit: "warning",
+      multiple_net_names: "warning",
+      net_not_bus_member: "warning",
+      no_connect_connected: "warning",
+      no_connect_dangling: "warning",
+      pin_not_connected: "error",
+      pin_not_driven: "error",
+      pin_to_pin: "warning",
+      power_pin_not_driven: "error",
+      similar_labels: "warning",
+      simulation_model_issue: "ignore",
+      unannotated: "error",
+      unit_value_mismatch: "error",
+      unresolved_variable: "error",
+      wire_dangling: "error"
+    }
+  },
+  libraries: {
+    pinned_footprint_libs: [],
+    pinned_symbol_libs: []
+  },
+  meta: {
+    filename: `${project_name}.kicad_pro`,
+    version: 1
+  },
+  net_settings: {
+    classes: [
+      {
+        bus_width: 12,
+        clearance: 0.2,
+        diff_pair_gap: 0.25,
+        diff_pair_via_gap: 0.25,
+        diff_pair_width: 0.2,
+        line_style: 0,
+        microvia_diameter: 0.3,
+        microvia_drill: 0.1,
+        name: "Default",
+        pcb_color: "rgba(0, 0, 0, 0.000)",
+        schematic_color: "rgba(0, 0, 0, 0.000)",
+        track_width: 0.2,
+        via_diameter: 0.6,
+        via_drill: 0.3,
+        wire_width: 6
+      }
+    ],
+    meta: {
+      version: 3
+    },
+    net_colors: null,
+    netclass_assignments: null,
+    netclass_patterns: []
+  },
+  pcbnew: {
+    last_paths: {
+      gencad: "",
+      idf: "",
+      netlist: "",
+      plot: "",
+      pos_files: "",
+      specctra_dsn: "",
+      step: "",
+      svg: "",
+      vrml: ""
+    }
+    // page_layout_descr_file: 'layout_frame.kicad_wks',
+  },
+  schematic: {
+    annotate_start_num: 0,
+    bom_export_filename: "",
+    bom_fmt_presets: [],
+    bom_fmt_settings: {
+      field_delimiter: ",",
+      keep_line_breaks: false,
+      keep_tabs: false,
+      name: "CSV",
+      ref_delimiter: ",",
+      ref_range_delimiter: "",
+      string_delimiter: '"'
+    },
+    bom_presets: [],
+    bom_settings: {
+      exclude_dnp: false,
+      fields_ordered: [
+        {
+          group_by: false,
+          label: "Reference",
+          name: "Reference",
+          show: true
+        },
+        {
+          group_by: true,
+          label: "Value",
+          name: "Value",
+          show: true
+        },
+        {
+          group_by: false,
+          label: "Datasheet",
+          name: "Datasheet",
+          show: true
+        },
+        {
+          group_by: false,
+          label: "Footprint",
+          name: "Footprint",
+          show: true
+        },
+        {
+          group_by: false,
+          label: "Qty",
+          name: "${QUANTITY}",
+          show: true
+        },
+        {
+          group_by: true,
+          label: "DNP",
+          name: "${DNP}",
+          show: true
+        }
+      ],
+      filter_string: "",
+      group_symbols: true,
+      name: "Grouped By Value",
+      sort_asc: true,
+      sort_field: "Reference"
+    },
+    connection_grid_size: 50,
+    drawing: {
+      dashed_lines_dash_length_ratio: 12,
+      dashed_lines_gap_length_ratio: 3,
+      default_line_thickness: 6,
+      default_text_size: 50,
+      field_names: [],
+      intersheets_ref_own_page: false,
+      intersheets_ref_prefix: "",
+      intersheets_ref_short: false,
+      intersheets_ref_show: false,
+      intersheets_ref_suffix: "",
+      junction_size_choice: 3,
+      label_size_ratio: 0.375,
+      operating_point_overlay_i_precision: 3,
+      operating_point_overlay_i_range: "~A",
+      operating_point_overlay_v_precision: 3,
+      operating_point_overlay_v_range: "~V",
+      overbar_offset_ratio: 1.23,
+      pin_symbol_size: 25,
+      text_offset_ratio: 0.15
+    },
+    legacy_lib_dir: "",
+    legacy_lib_list: [],
+    meta: {
+      version: 1
+    },
+    net_format_name: "",
+    page_layout_descr_file: `${project_name}.${DrawingSheetFileExtension}`,
+    plot_directory: "",
+    spice_current_sheet_as_root: false,
+    spice_external_command: 'spice "%I"',
+    spice_model_current_sheet_as_root: true,
+    spice_save_all_currents: false,
+    spice_save_all_dissipations: false,
+    spice_save_all_voltages: false,
+    subpart_first_id: 65,
+    subpart_id_separator: 0
+  },
+  sheets: [],
+  text_variables: {}
+});
+
+// src/kicad/project/kicad_project_archive.ts
+var KICAD_SCH_FRAME = get_sch_default_drawing_sheet();
+var KiCadProjectArchive = class {
+  constructor(project_name, sheets) {
+    this.project_name = project_name;
+    this.sheets = sheets;
+  }
+  get sch_frame() {
+    return KICAD_SCH_FRAME;
+  }
+  get kicad_prl() {
+    return kicad_prl(this.project_name);
+  }
+  get kicad_pro() {
+    return kicad_pro(this.project_name);
+  }
+  get_project_directive_file_name(ext) {
+    return `${this.project_name}.${ext}`;
+  }
+  toZip() {
+    return zipFiles({
+      [this.get_project_directive_file_name(ProjectLocalSettingsFileExtension)]: JSON.stringify(this.kicad_prl),
+      [this.get_project_directive_file_name(ProjectFileExtension)]: JSON.stringify(this.kicad_pro),
+      [this.get_project_directive_file_name(DrawingSheetFileExtension)]: this.sch_frame,
+      ...this.sheets
+    });
+  }
+};
+
+// src/builder/graph_to_kicad/do_convert_graph_to_kicad_project.ts
+async function do_convert_graph_to_kicad_project(ctx) {
+  const { sheets } = await collect_sub_sheets(ctx.project.dependencies, ctx.module_resolver);
+  const netlist = new GraphConverter({
+    ...ctx
+  }).convert_to_netlist();
+  const converted_sheets = await new NetListConverter({
+    ...ctx,
+    netlist
+  }).convert_to_kicad();
+  const sexpr_printer = new SCHEMATIC_PRINTER();
+  for (const [k, v] of Object.entries(converted_sheets)) {
+    if (k in sheets) {
+      console.error(`Duplicated sheet file name found ${k}`);
+    }
+    sheets[k.replace(MODULAR_CIRCUIT_SCH_EXT2, KiCadSchematicFileExtension)] = sexpr_printer.schematic(v);
+  }
+  const kicad_project = new KiCadProjectArchive(ctx.project.name, {
+    ...sheets
+  });
+  return kicad_project.toZip();
+}
+
+// src/builder/graph_to_kicad/index.ts
+async function convert_graph_to_kicad_project(ctx) {
+  return do_convert_graph_to_kicad_project({
+    ...ctx,
+    ...await build_connection_graph({ ...ctx, dependencies: ctx.project.dependencies })
+  });
+}
+export {
+  AllegroNetlistFileExtension,
+  AltiumFootprintLibPathExtension,
+  ArchiveFileExtension,
+  BLOCK_PIN_GAP,
+  BLOCK_PIN_TB_MARGIN,
+  CadstarFootprintLibPathExtension,
+  CadstarNetlistFileExtension,
+  CadstarPartsLibraryFileExtension,
+  CadstarPcbFileExtension,
+  CadstarSchematicFileExtension,
+  CsvFileExtension,
+  DEFAULT_PAPER_SIZE,
+  DatabaseLibraryFileExtension,
+  DesignRulesFileExtension,
+  DrawingSheetFileExtension,
+  DrillFileExtension,
+  EagleFootprintLibPathExtension,
+  EaglePcbFileExtension,
+  EquFileExtension,
+  FONT_SIZE,
+  FootprintAssignmentFileExtension,
+  FootprintPlaceFileExtension,
+  GENERATOR_NAME,
+  GENERATOR_VERSION,
+  GRID_SIZE,
+  GedaPcbFootprintLibFileExtension,
+  GerberFileExtension,
+  GerberFileExtensionsRegex,
+  GerberJobFileExtension,
+  GltfBinaryFileExtension,
+  GraphConverter,
+  HTTPLibraryFileExtension,
+  HotkeyFileExtension,
+  HtmlFileExtension,
+  Ipc2581FileExtension,
+  IpcD356FileExtension,
+  JpegFileExtension,
+  JsonFileExtension,
+  KICAD_SCH_FRAME,
+  KiCadFootprintFileExtension,
+  KiCadFootprintLibPathExtension,
+  KiCadPcbFileExtension,
+  KiCadProjectArchive,
+  KiCadSchematicFileExtension,
+  KiCadSymbolLibFileExtension,
+  Layout,
+  LegacyFootprintLibPathExtension,
+  LegacyPcbFileExtension,
+  LegacyProjectFileExtension,
+  LegacySchematicFileExtension,
+  LegacySymbolDocumentFileExtension,
+  LegacySymbolLibFileExtension,
+  MacrosFileExtension,
+  MarkdownFileExtension,
+  NetListConverter,
+  NetlistFileExtension,
+  OrCadPcb2NetlistFileExtension,
+  PAPER,
+  PAPER_SIZE,
+  PdfFileExtension,
+  PngFileExtension,
+  ProjectFileExtension,
+  ProjectLocalSettingsFileExtension,
+  ReportFileExtension,
+  SCHEMATIC_PRINTER,
+  SCH_VERSION,
+  SVGFileExtension,
+  SchematicSymbolFileExtension,
+  SpecctraDsnFileExtension,
+  SpecctraSessionFileExtension,
+  SpiceFileExtension,
+  StepFileAbrvExtension,
+  StepFileExtension,
+  StringFormatter,
+  TextFileExtension,
+  VrmlFileExtension,
+  WIRE_PADDING,
+  WorkbookFileExtension,
+  XmlFileExtension,
+  collect_sub_sheets,
+  collect_sub_sheets_by_id,
+  convert_graph_to_kicad_project,
+  filterNullOrUndefined,
+  gen_lib_gnd,
+  gen_lib_vcc,
+  gen_sch_gnd,
+  gen_sch_vcc,
+  get_power_pos,
+  get_sch_default_drawing_sheet,
+  tab
+};