@ttsc/graph 0.30.3 → 0.31.0

package/lib/model/TtscGraphProtocol.js

@@ -0,0 +1,928 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TtscGraphProtocol = void 0;
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const typia_1 = __importDefault(require("typia"));
+/**
+ * The serve protocol version this client speaks.
+ *
+ * Keep it equal to `serveProtocolVersion` in
+ * `packages/ttsc/cmd/ttscgraph/serve.go`. The two are hand-synchronized.
+ */
+const PROTOCOL_VERSION = 1;
+/**
+ * Decode the graph serve envelope before any state or body facts are consumed.
+ *
+ * @evidence contracts/common.md#principled-implementation JSON framing, protocol agreement and generated complete-envelope validation precede typed state admission.
+ * @evidence contracts/common.md#clear-and-simple-design The decoder owns the wire contract; state owns correlation and generation semantics after this boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The installed typia transform validates the declared envelope rather than a partial cast or handwritten schema replacement.
+ * @evidence contracts/common.md#meaningful-documentation Native comments explain why protocol agreement must precede shape validation and why routing fields belong in the envelope.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms decode owns JSON and generated envelope validation; the namespace adds no processing algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work decode validates each submitted line, while state establishes reuse of graph generations.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace retains no decoded frame or native handle; its caller owns typed results.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation a JSON line decoder; it reads no file, path or process.
+ */
+var TtscGraphProtocol;
+(function (TtscGraphProtocol) {
+    /**
+     * Decode one line or throw the owned framing/version/schema diagnostic.
+     *
+     * @evidence contracts/common.md#principled-implementation JSON parsing precedes protocol agreement and generated complete-envelope validation, so no field is routed before its declared wire contract holds.
+     * @evidence contracts/common.md#clear-and-simple-design This single decoder supplies typed inputs to state; state owns pending correlation, schema body agreement and generation semantics.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Installed typia validates the whole declared envelope rather than a handwritten partial guard or a fabricated trusted frame.
+     * @evidence contracts/common.md#meaningful-documentation The headline states owned failure behavior; private comments explain version-before-shape and routing-field validation.
+     * @evidence contracts/performance.md#efficient-algorithms JSON parsing and generated field traversal process the line and carried graph facts linearly; no project, directory or historical-frame scan occurs.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each submitted wire line requires validation; graph state alone coordinates current-model reuse.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Parsed values and error text are local; the typed result transfers to state and no native reader, child or frame history is retained.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation parses one line of JSON text and validates it; no file, path or process.
+     */
+    function decode(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (error) {
+            throw new Error(`@ttsc/graph: native session returned invalid JSON: ${asError(error).message}`);
+        }
+        // Read the version before the shape, because a server speaking another
+        // version is entitled to a different shape. Asserting first would report
+        // that mismatch as a field complaint — "expected string at $input.mode" —
+        // about a contract the other side never agreed to, which is the misparse
+        // this field exists to prevent. Ask what protocol it is first, then hold it
+        // to that protocol.
+        const version = (() => {
+            const _io0 = input => "number" === typeof input.protocolVersion;
+            return input => "object" === typeof input && null !== input && _io0(input);
+        })()(parsed) ? parsed.protocolVersion
+            : undefined;
+        if (version !== PROTOCOL_VERSION) {
+            // Session-wide: a version mismatch is not one bad frame, it is the wrong
+            // binary, and every request against it is equally doomed.
+            throw new Error(`@ttsc/graph: ttscgraph speaks serve protocol ${version === undefined ? "an unknown version" : `v${String(version)}`}, this client speaks v${String(PROTOCOL_VERSION)}. ` +
+                "Install a matching `ttsc` (the binary resolves from the target " +
+                "project, or from TTSC_GRAPH_BINARY).");
+        }
+        let response;
+        try {
+            // Validate the envelope, not just the dump it carries. The dump was
+            // typia-asserted while the envelope around it was a bare cast, so the
+            // fields the client actually branches on — the mode, and the id that
+            // routes the frame — were the unchecked ones. Anything added to the
+            // envelope belongs on this side of that line.
+            response = (() => {
+                const _ip0 = input => "number" === typeof input["protocolVersion"];
+                const _ip1 = input => Array.isArray(input["capabilities"]) && input["capabilities"].every(elem => "string" === typeof elem);
+                const _ip2 = input => "string" === typeof input["project"];
+                const _ip3 = input => "string" === typeof input["tsconfig"];
+                const _ip4 = input => Array.isArray(input["diagnostics"]) && input["diagnostics"].every(elem => "object" === typeof elem && null !== elem && _io8(elem));
+                const _ip5 = input => Array.isArray(input["nodes"]) && input["nodes"].every(elem => "object" === typeof elem && null !== elem && _io9(elem));
+                const _ip6 = input => Array.isArray(input["edges"]) && input["edges"].every(elem => "object" === typeof elem && null !== elem && _io16(elem));
+                const _ip7 = input => "number" === typeof input["schemaVersion"];
+                const _ip8 = input => "object" === typeof input["producer"] && null !== input["producer"] && _io3(input["producer"]);
+                const _ip9 = input => "object" === typeof input["universe"] && null !== input["universe"] && _io4(input["universe"]);
+                const _ip10 = input => "string" === typeof input["file"];
+                const _ip11 = input => "string" === typeof input["digest"];
+                const _ip12 = input => "string" === typeof input["id"];
+                const _ip13 = input => "string" === typeof input["name"];
+                const _ip14 = input => undefined === input["qualifiedName"] || "string" === typeof input["qualifiedName"];
+                const _ip15 = input => "boolean" === typeof input["external"];
+                const _ip16 = input => undefined === input["ignored"] || "boolean" === typeof input["ignored"];
+                const _ip17 = input => undefined === input["exported"] || "boolean" === typeof input["exported"];
+                const _ip18 = input => undefined === input["closure"] || "boolean" === typeof input["closure"];
+                const _ip19 = input => undefined === input["modifiers"] || Array.isArray(input["modifiers"]) && input["modifiers"].every(elem => true === _iv0.has(elem));
+                const _iv0 = new Set(["abstract", "async", "const", "declare", "default", "export", "private", "protected", "public", "readonly", "static"]);
+                const _ip20 = input => undefined === input["literals"] || Array.isArray(input["literals"]) && input["literals"].every(elem => "string" === typeof elem);
+                const _ip21 = input => undefined === input["enumMembers"] || Array.isArray(input["enumMembers"]) && input["enumMembers"].every(elem => "object" === typeof elem && null !== elem && _io10(elem));
+                const _ip22 = input => undefined === input["objectMembers"] || Array.isArray(input["objectMembers"]) && input["objectMembers"].every(elem => "object" === typeof elem && null !== elem && _io11(elem));
+                const _ip23 = input => undefined === input["decorators"] || Array.isArray(input["decorators"]) && input["decorators"].every(elem => "object" === typeof elem && null !== elem && _io12(elem));
+                const _ip24 = input => undefined === input["docTags"] || Array.isArray(input["docTags"]) && input["docTags"].every(elem => "object" === typeof elem && null !== elem && _io14(elem));
+                const _ip25 = input => undefined === input["signature"] || "string" === typeof input["signature"];
+                const _ip26 = input => true === _iv1.has(input["kind"]);
+                const _iv1 = new Set(["class", "enum", "function", "interface", "markdown_document", "markdown_section", "method", "module", "prisma_column", "prisma_model", "prisma_relation", "swagger_operation", "type", "variable"]);
+                const _ip27 = input => undefined === input["parent"] || "string" === typeof input["parent"];
+                const _ip28 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io15(input["evidence"]);
+                const _ip29 = input => undefined === input["implementation"] || "object" === typeof input["implementation"] && null !== input["implementation"] && _io15(input["implementation"]);
+                const _iv2 = new Set(["accesses", "calls", "doc_ref", "exports", "extends", "implements", "instantiates", "overrides", "renders", "type_ref"]);
+                const _ip30 = input => "string" === typeof input["key"];
+                const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["protocolVersion"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".protocolVersion",
+                    expected: "number",
+                    value: input["protocolVersion"]
+                }, _errorFactory);
+                const _ap1 = (input, _path, _exceptionable = true) => (Array.isArray(input["capabilities"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".capabilities",
+                    expected: "Array<string>",
+                    value: input["capabilities"]
+                }, _errorFactory)) && input["capabilities"].every((elem, _index18) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".capabilities[" + _index18 + "]",
+                    expected: "string",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".capabilities",
+                    expected: "Array<string>",
+                    value: input["capabilities"]
+                }, _errorFactory);
+                const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["project"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".project",
+                    expected: "string",
+                    value: input["project"]
+                }, _errorFactory);
+                const _ap3 = (input, _path, _exceptionable = true) => "string" === typeof input["tsconfig"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".tsconfig",
+                    expected: "string",
+                    value: input["tsconfig"]
+                }, _errorFactory);
+                const _ap4 = (input, _path, _exceptionable = true) => (Array.isArray(input["diagnostics"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics",
+                    expected: "Array<ITtscGraphDump.IDiagnostic>",
+                    value: input["diagnostics"]
+                }, _errorFactory)) && input["diagnostics"].every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics[" + _index19 + "]",
+                    expected: "ITtscGraphDump.IDiagnostic",
+                    value: elem
+                }, _errorFactory)) && _ao8(elem, _path + ".diagnostics[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics[" + _index19 + "]",
+                    expected: "ITtscGraphDump.IDiagnostic",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics",
+                    expected: "Array<ITtscGraphDump.IDiagnostic>",
+                    value: input["diagnostics"]
+                }, _errorFactory);
+                const _ap5 = (input, _path, _exceptionable = true) => (Array.isArray(input["nodes"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes",
+                    expected: "Array<ITtscGraphDump.INode>",
+                    value: input["nodes"]
+                }, _errorFactory)) && input["nodes"].every((elem, _index20) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes[" + _index20 + "]",
+                    expected: "ITtscGraphDump.INode",
+                    value: elem
+                }, _errorFactory)) && _ao9(elem, _path + ".nodes[" + _index20 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes[" + _index20 + "]",
+                    expected: "ITtscGraphDump.INode",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes",
+                    expected: "Array<ITtscGraphDump.INode>",
+                    value: input["nodes"]
+                }, _errorFactory);
+                const _ap6 = (input, _path, _exceptionable = true) => (Array.isArray(input["edges"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges",
+                    expected: "Array<ITtscGraphDump.IEdge>",
+                    value: input["edges"]
+                }, _errorFactory)) && input["edges"].every((elem, _index21) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges[" + _index21 + "]",
+                    expected: "ITtscGraphDump.IEdge",
+                    value: elem
+                }, _errorFactory)) && _ao16(elem, _path + ".edges[" + _index21 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges[" + _index21 + "]",
+                    expected: "ITtscGraphDump.IEdge",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges",
+                    expected: "Array<ITtscGraphDump.IEdge>",
+                    value: input["edges"]
+                }, _errorFactory);
+                const _ap7 = (input, _path, _exceptionable = true) => "number" === typeof input["schemaVersion"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".schemaVersion",
+                    expected: "number",
+                    value: input["schemaVersion"]
+                }, _errorFactory);
+                const _ap8 = (input, _path, _exceptionable = true) => ("object" === typeof input["producer"] && null !== input["producer"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".producer",
+                    expected: "ITtscGraphDump.IProducer",
+                    value: input["producer"]
+                }, _errorFactory)) && _ao3(input["producer"], _path + ".producer", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".producer",
+                    expected: "ITtscGraphDump.IProducer",
+                    value: input["producer"]
+                }, _errorFactory);
+                const _ap9 = (input, _path, _exceptionable = true) => ("object" === typeof input["universe"] && null !== input["universe"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".universe",
+                    expected: "ITtscGraphDump.IUniverse",
+                    value: input["universe"]
+                }, _errorFactory)) && _ao4(input["universe"], _path + ".universe", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".universe",
+                    expected: "ITtscGraphDump.IUniverse",
+                    value: input["universe"]
+                }, _errorFactory);
+                const _ap10 = (input, _path, _exceptionable = true) => "string" === typeof input["file"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".file",
+                    expected: "string",
+                    value: input["file"]
+                }, _errorFactory);
+                const _ap11 = (input, _path, _exceptionable = true) => "string" === typeof input["digest"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".digest",
+                    expected: "string",
+                    value: input["digest"]
+                }, _errorFactory);
+                const _ap12 = (input, _path, _exceptionable = true) => "string" === typeof input["id"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".id",
+                    expected: "string",
+                    value: input["id"]
+                }, _errorFactory);
+                const _ap13 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".name",
+                    expected: "string",
+                    value: input["name"]
+                }, _errorFactory);
+                const _ap14 = (input, _path, _exceptionable = true) => undefined === input["qualifiedName"] || "string" === typeof input["qualifiedName"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".qualifiedName",
+                    expected: "(string | undefined)",
+                    value: input["qualifiedName"]
+                }, _errorFactory);
+                const _ap15 = (input, _path, _exceptionable = true) => "boolean" === typeof input["external"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".external",
+                    expected: "boolean",
+                    value: input["external"]
+                }, _errorFactory);
+                const _ap16 = (input, _path, _exceptionable = true) => undefined === input["ignored"] || "boolean" === typeof input["ignored"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".ignored",
+                    expected: "(boolean | undefined)",
+                    value: input["ignored"]
+                }, _errorFactory);
+                const _ap17 = (input, _path, _exceptionable = true) => undefined === input["exported"] || "boolean" === typeof input["exported"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".exported",
+                    expected: "(boolean | undefined)",
+                    value: input["exported"]
+                }, _errorFactory);
+                const _ap18 = (input, _path, _exceptionable = true) => undefined === input["closure"] || "boolean" === typeof input["closure"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".closure",
+                    expected: "(boolean | undefined)",
+                    value: input["closure"]
+                }, _errorFactory);
+                const _ap19 = (input, _path, _exceptionable = true) => undefined === input["modifiers"] || (Array.isArray(input["modifiers"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".modifiers",
+                    expected: "(Array<TtscGraphNodeModifier> | undefined)",
+                    value: input["modifiers"]
+                }, _errorFactory)) && input["modifiers"].every((elem, _index25) => true === _av0.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".modifiers[" + _index25 + "]",
+                    expected: _ae0,
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".modifiers",
+                    expected: "(Array<TtscGraphNodeModifier> | undefined)",
+                    value: input["modifiers"]
+                }, _errorFactory);
+                const _av0 = new Set(["abstract", "async", "const", "declare", "default", "export", "private", "protected", "public", "readonly", "static"]);
+                const _ae0 = "(\"abstract\" | \"async\" | \"const\" | \"declare\" | \"default\" | \"export\" | \"private\" | \"protected\" | \"public\" | \"readonly\" | \"static\")";
+                const _ap20 = (input, _path, _exceptionable = true) => undefined === input["literals"] || (Array.isArray(input["literals"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".literals",
+                    expected: "(Array<string> | undefined)",
+                    value: input["literals"]
+                }, _errorFactory)) && input["literals"].every((elem, _index26) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".literals[" + _index26 + "]",
+                    expected: "string",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".literals",
+                    expected: "(Array<string> | undefined)",
+                    value: input["literals"]
+                }, _errorFactory);
+                const _ap21 = (input, _path, _exceptionable = true) => undefined === input["enumMembers"] || (Array.isArray(input["enumMembers"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".enumMembers",
+                    expected: "(Array<ITtscGraphNode.IEnumMember> | undefined)",
+                    value: input["enumMembers"]
+                }, _errorFactory)) && input["enumMembers"].every((elem, _index27) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".enumMembers[" + _index27 + "]",
+                    expected: "ITtscGraphNode.IEnumMember",
+                    value: elem
+                }, _errorFactory)) && _ao10(elem, _path + ".enumMembers[" + _index27 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".enumMembers[" + _index27 + "]",
+                    expected: "ITtscGraphNode.IEnumMember",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".enumMembers",
+                    expected: "(Array<ITtscGraphNode.IEnumMember> | undefined)",
+                    value: input["enumMembers"]
+                }, _errorFactory);
+                const _ap22 = (input, _path, _exceptionable = true) => undefined === input["objectMembers"] || (Array.isArray(input["objectMembers"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".objectMembers",
+                    expected: "(Array<ITtscGraphNode.IObjectMember> | undefined)",
+                    value: input["objectMembers"]
+                }, _errorFactory)) && input["objectMembers"].every((elem, _index28) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".objectMembers[" + _index28 + "]",
+                    expected: "ITtscGraphNode.IObjectMember",
+                    value: elem
+                }, _errorFactory)) && _ao11(elem, _path + ".objectMembers[" + _index28 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".objectMembers[" + _index28 + "]",
+                    expected: "ITtscGraphNode.IObjectMember",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".objectMembers",
+                    expected: "(Array<ITtscGraphNode.IObjectMember> | undefined)",
+                    value: input["objectMembers"]
+                }, _errorFactory);
+                const _ap23 = (input, _path, _exceptionable = true) => undefined === input["decorators"] || (Array.isArray(input["decorators"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators",
+                    expected: "(Array<ITtscGraphDecorator> | undefined)",
+                    value: input["decorators"]
+                }, _errorFactory)) && input["decorators"].every((elem, _index29) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators[" + _index29 + "]",
+                    expected: "ITtscGraphDecorator",
+                    value: elem
+                }, _errorFactory)) && _ao12(elem, _path + ".decorators[" + _index29 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators[" + _index29 + "]",
+                    expected: "ITtscGraphDecorator",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators",
+                    expected: "(Array<ITtscGraphDecorator> | undefined)",
+                    value: input["decorators"]
+                }, _errorFactory);
+                const _ap24 = (input, _path, _exceptionable = true) => undefined === input["docTags"] || (Array.isArray(input["docTags"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".docTags",
+                    expected: "(Array<ITtscGraphDocTag> | undefined)",
+                    value: input["docTags"]
+                }, _errorFactory)) && input["docTags"].every((elem, _index30) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".docTags[" + _index30 + "]",
+                    expected: "ITtscGraphDocTag",
+                    value: elem
+                }, _errorFactory)) && _ao14(elem, _path + ".docTags[" + _index30 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".docTags[" + _index30 + "]",
+                    expected: "ITtscGraphDocTag",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".docTags",
+                    expected: "(Array<ITtscGraphDocTag> | undefined)",
+                    value: input["docTags"]
+                }, _errorFactory);
+                const _ap25 = (input, _path, _exceptionable = true) => undefined === input["signature"] || "string" === typeof input["signature"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".signature",
+                    expected: "(string | undefined)",
+                    value: input["signature"]
+                }, _errorFactory);
+                const _ap26 = (input, _path, _exceptionable = true) => true === _av1.has(input["kind"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".kind",
+                    expected: _ae1,
+                    value: input["kind"]
+                }, _errorFactory);
+                const _av1 = new Set(["class", "enum", "function", "interface", "markdown_document", "markdown_section", "method", "module", "prisma_column", "prisma_model", "prisma_relation", "swagger_operation", "type", "variable"]);
+                const _ae1 = "(\"class\" | \"enum\" | \"function\" | \"interface\" | \"markdown_document\" | \"markdown_section\" | \"method\" | \"module\" | \"prisma_column\" | \"prisma_model\" | \"prisma_relation\" | \"swagger_operation\" | \"type\" | \"variable\")";
+                const _ap27 = (input, _path, _exceptionable = true) => undefined === input["parent"] || "string" === typeof input["parent"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".parent",
+                    expected: "(string | undefined)",
+                    value: input["parent"]
+                }, _errorFactory);
+                const _ap28 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".evidence",
+                    expected: "(ITtscGraphSpan | undefined)",
+                    value: input["evidence"]
+                }, _errorFactory)) && _ao15(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".evidence",
+                    expected: "(ITtscGraphSpan | undefined)",
+                    value: input["evidence"]
+                }, _errorFactory);
+                const _ap29 = (input, _path, _exceptionable = true) => undefined === input["implementation"] || ("object" === typeof input["implementation"] && null !== input["implementation"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".implementation",
+                    expected: "(ITtscGraphSpan | undefined)",
+                    value: input["implementation"]
+                }, _errorFactory)) && _ao15(input["implementation"], _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".implementation",
+                    expected: "(ITtscGraphSpan | undefined)",
+                    value: input["implementation"]
+                }, _errorFactory);
+                const _av2 = new Set(["accesses", "calls", "doc_ref", "exports", "extends", "implements", "instantiates", "overrides", "renders", "type_ref"]);
+                const _ae2 = "(\"accesses\" | \"calls\" | \"doc_ref\" | \"exports\" | \"extends\" | \"implements\" | \"instantiates\" | \"overrides\" | \"renders\" | \"type_ref\")";
+                const _ap30 = (input, _path, _exceptionable = true) => "string" === typeof input["key"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".key",
+                    expected: "string",
+                    value: input["key"]
+                }, _errorFactory);
+                const _ao0 = (input, _path, _exceptionable = true) => ("number" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".id",
+                    expected: "number",
+                    value: input.id
+                }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && ("error" === input.mode || "incremental" === input.mode || "initial" === input.mode || "rebuild" === input.mode || "reload" === input.mode || "unchanged" === input.mode || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".mode",
+                    expected: "(\"error\" | \"incremental\" | \"initial\" | \"rebuild\" | \"reload\" | \"unchanged\")",
+                    value: input.mode
+                }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && ("boolean" === typeof input.changed || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".changed",
+                    expected: "boolean",
+                    value: input.changed
+                }, _errorFactory)) && (undefined === input.dump || ("object" === typeof input.dump && null !== input.dump || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".dump",
+                    expected: "(ITtscGraphDump | undefined)",
+                    value: input.dump
+                }, _errorFactory)) && _ao1(input.dump, _path + ".dump", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".dump",
+                    expected: "(ITtscGraphDump | undefined)",
+                    value: input.dump
+                }, _errorFactory)) && (undefined === input.snapshot || ("object" === typeof input.snapshot && null !== input.snapshot || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".snapshot",
+                    expected: "(ITtscGraphSnapshot.ITransaction | undefined)",
+                    value: input.snapshot
+                }, _errorFactory)) && _ao17(input.snapshot, _path + ".snapshot", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".snapshot",
+                    expected: "(ITtscGraphSnapshot.ITransaction | undefined)",
+                    value: input.snapshot
+                }, _errorFactory)) && (undefined === input.error || "string" === typeof input.error || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".error",
+                    expected: "(string | undefined)",
+                    value: input.error
+                }, _errorFactory));
+                const _ao1 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && (("object" === typeof input.provenance && null !== input.provenance || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".provenance",
+                    expected: "ITtscGraphDump.IProvenance",
+                    value: input.provenance
+                }, _errorFactory)) && _ao2(input.provenance, _path + ".provenance", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".provenance",
+                    expected: "ITtscGraphDump.IProvenance",
+                    value: input.provenance
+                }, _errorFactory)) && _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable);
+                const _ao10 = (input, _path, _exceptionable = true) => _ap13(input, _path, true && _exceptionable) && (undefined === input.value || "string" === typeof input.value || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".value",
+                    expected: "(string | undefined)",
+                    value: input.value
+                }, _errorFactory));
+                const _ao11 = (input, _path, _exceptionable = true) => _ap13(input, _path, true && _exceptionable) && ("method" === input.kind || "property" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".kind",
+                    expected: "(\"method\" | \"property\")",
+                    value: input.kind
+                }, _errorFactory)) && (undefined === input.line || "number" === typeof input.line || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".line",
+                    expected: "(number | undefined)",
+                    value: input.line
+                }, _errorFactory)) && _ap25(input, _path, true && _exceptionable);
+                const _ao12 = (input, _path, _exceptionable = true) => _ap13(input, _path, true && _exceptionable) && ((Array.isArray(input.arguments) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments",
+                    expected: "Array<ITtscGraphDecorator.IArgument>",
+                    value: input.arguments
+                }, _errorFactory)) && input.arguments.every((elem, _index31) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments[" + _index31 + "]",
+                    expected: "ITtscGraphDecorator.IArgument",
+                    value: elem
+                }, _errorFactory)) && _ao13(elem, _path + ".arguments[" + _index31 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments[" + _index31 + "]",
+                    expected: "ITtscGraphDecorator.IArgument",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments",
+                    expected: "Array<ITtscGraphDecorator.IArgument>",
+                    value: input.arguments
+                }, _errorFactory));
+                const _ao13 = (input, _path, _exceptionable = true) => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".literal",
+                    expected: "(boolean | number | string | undefined)",
+                    value: input.literal
+                }, _errorFactory);
+                const _ao14 = (input, _path, _exceptionable = true) => _ap13(input, _path, true && _exceptionable) && (undefined === input.text || "string" === typeof input.text || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".text",
+                    expected: "(string | undefined)",
+                    value: input.text
+                }, _errorFactory));
+                const _ao15 = (input, _path, _exceptionable = true) => (undefined === input.file || "string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".file",
+                    expected: "(string | undefined)",
+                    value: input.file
+                }, _errorFactory)) && ("number" === typeof input.startLine || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".startLine",
+                    expected: "number",
+                    value: input.startLine
+                }, _errorFactory)) && (undefined === input.startCol || "number" === typeof input.startCol || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".startCol",
+                    expected: "(number | undefined)",
+                    value: input.startCol
+                }, _errorFactory)) && (undefined === input.endLine || "number" === typeof input.endLine || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".endLine",
+                    expected: "(number | undefined)",
+                    value: input.endLine
+                }, _errorFactory)) && (undefined === input.endCol || "number" === typeof input.endCol || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".endCol",
+                    expected: "(number | undefined)",
+                    value: input.endCol
+                }, _errorFactory));
+                const _ao16 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".from",
+                    expected: "string",
+                    value: input.from
+                }, _errorFactory)) && ("string" === typeof input.to || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".to",
+                    expected: "string",
+                    value: input.to
+                }, _errorFactory)) && (true === _av2.has(input.kind) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".kind",
+                    expected: _ae2,
+                    value: input.kind
+                }, _errorFactory)) && _ap28(input, _path, true && _exceptionable);
+                const _ao17 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && ("number" === typeof input.sequence || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".sequence",
+                    expected: "number",
+                    value: input.sequence
+                }, _errorFactory)) && ("string" === typeof input.generation || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".generation",
+                    expected: "string",
+                    value: input.generation
+                }, _errorFactory)) && (undefined === input.baseSequence || "number" === typeof input.baseSequence || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".baseSequence",
+                    expected: "(number | undefined)",
+                    value: input.baseSequence
+                }, _errorFactory)) && (undefined === input.baseGeneration || "string" === typeof input.baseGeneration || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".baseGeneration",
+                    expected: "(string | undefined)",
+                    value: input.baseGeneration
+                }, _errorFactory)) && ((Array.isArray(input.upserts) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".upserts",
+                    expected: "Array<ITtscGraphSnapshot.IShardUpsert>",
+                    value: input.upserts
+                }, _errorFactory)) && input.upserts.every((elem, _index32) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".upserts[" + _index32 + "]",
+                    expected: "ITtscGraphSnapshot.IShardUpsert",
+                    value: elem
+                }, _errorFactory)) && _ao18(elem, _path + ".upserts[" + _index32 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".upserts[" + _index32 + "]",
+                    expected: "ITtscGraphSnapshot.IShardUpsert",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".upserts",
+                    expected: "Array<ITtscGraphSnapshot.IShardUpsert>",
+                    value: input.upserts
+                }, _errorFactory)) && ((Array.isArray(input.deletes) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".deletes",
+                    expected: "Array<string>",
+                    value: input.deletes
+                }, _errorFactory)) && input.deletes.every((elem, _index33) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".deletes[" + _index33 + "]",
+                    expected: "string",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".deletes",
+                    expected: "Array<string>",
+                    value: input.deletes
+                }, _errorFactory)) && ((Array.isArray(input.manifest) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".manifest",
+                    expected: "Array<ITtscGraphSnapshot.IShardReference>",
+                    value: input.manifest
+                }, _errorFactory)) && input.manifest.every((elem, _index34) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".manifest[" + _index34 + "]",
+                    expected: "ITtscGraphSnapshot.IShardReference",
+                    value: elem
+                }, _errorFactory)) && _ao20(elem, _path + ".manifest[" + _index34 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".manifest[" + _index34 + "]",
+                    expected: "ITtscGraphSnapshot.IShardReference",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".manifest",
+                    expected: "Array<ITtscGraphSnapshot.IShardReference>",
+                    value: input.manifest
+                }, _errorFactory));
+                const _ao18 = (input, _path, _exceptionable = true) => _ap11(input, _path, true && _exceptionable) && (("object" === typeof input.shard && null !== input.shard || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".shard",
+                    expected: "ITtscGraphSnapshot.IShard",
+                    value: input.shard
+                }, _errorFactory)) && _ao19(input.shard, _path + ".shard", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".shard",
+                    expected: "ITtscGraphSnapshot.IShard",
+                    value: input.shard
+                }, _errorFactory));
+                const _ao19 = (input, _path, _exceptionable = true) => _ap30(input, _path, true && _exceptionable) && (undefined === input.source || ("object" === typeof input.source && null !== input.source || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".source",
+                    expected: "(ITtscGraphDump.ISourceDigest | undefined)",
+                    value: input.source
+                }, _errorFactory)) && _ao7(input.source, _path + ".source", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".source",
+                    expected: "(ITtscGraphDump.ISourceDigest | undefined)",
+                    value: input.source
+                }, _errorFactory)) && (undefined === input.config || ("object" === typeof input.config && null !== input.config || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".config",
+                    expected: "(ITtscGraphDump.IFileDigest | undefined)",
+                    value: input.config
+                }, _errorFactory)) && _ao5(input.config, _path + ".config", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".config",
+                    expected: "(ITtscGraphDump.IFileDigest | undefined)",
+                    value: input.config
+                }, _errorFactory)) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable);
+                const _ao2 = (input, _path, _exceptionable = true) => _ap7(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable) && (undefined === input.artifactProducer || ("object" === typeof input.artifactProducer && null !== input.artifactProducer || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".artifactProducer",
+                    expected: "(ITtscGraphDump.IProducer | undefined)",
+                    value: input.artifactProducer
+                }, _errorFactory)) && _ao3(input.artifactProducer, _path + ".artifactProducer", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".artifactProducer",
+                    expected: "(ITtscGraphDump.IProducer | undefined)",
+                    value: input.artifactProducer
+                }, _errorFactory)) && _ap9(input, _path, true && _exceptionable) && ((Array.isArray(input.sources) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".sources",
+                    expected: "Array<ITtscGraphDump.ISourceDigest>",
+                    value: input.sources
+                }, _errorFactory)) && input.sources.every((elem, _index22) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".sources[" + _index22 + "]",
+                    expected: "ITtscGraphDump.ISourceDigest",
+                    value: elem
+                }, _errorFactory)) && _ao7(elem, _path + ".sources[" + _index22 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".sources[" + _index22 + "]",
+                    expected: "ITtscGraphDump.ISourceDigest",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".sources",
+                    expected: "Array<ITtscGraphDump.ISourceDigest>",
+                    value: input.sources
+                }, _errorFactory));
+                const _ao20 = (input, _path, _exceptionable = true) => _ap30(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable);
+                const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.tool || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".tool",
+                    expected: "string",
+                    value: input.tool
+                }, _errorFactory)) && ("string" === typeof input.version || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".version",
+                    expected: "string",
+                    value: input.version
+                }, _errorFactory)) && ("string" === typeof input.typescript || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".typescript",
+                    expected: "string",
+                    value: input.typescript
+                }, _errorFactory));
+                const _ao4 = (input, _path, _exceptionable = true) => ((Array.isArray(input.configs) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".configs",
+                    expected: "Array<ITtscGraphDump.IFileDigest>",
+                    value: input.configs
+                }, _errorFactory)) && input.configs.every((elem, _index23) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".configs[" + _index23 + "]",
+                    expected: "ITtscGraphDump.IFileDigest",
+                    value: elem
+                }, _errorFactory)) && _ao5(elem, _path + ".configs[" + _index23 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".configs[" + _index23 + "]",
+                    expected: "ITtscGraphDump.IFileDigest",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".configs",
+                    expected: "Array<ITtscGraphDump.IFileDigest>",
+                    value: input.configs
+                }, _errorFactory)) && ((Array.isArray(input.roots) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".roots",
+                    expected: "Array<ITtscGraphDump.IRootFile>",
+                    value: input.roots
+                }, _errorFactory)) && input.roots.every((elem, _index24) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".roots[" + _index24 + "]",
+                    expected: "ITtscGraphDump.IRootFile",
+                    value: elem
+                }, _errorFactory)) && _ao6(elem, _path + ".roots[" + _index24 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".roots[" + _index24 + "]",
+                    expected: "ITtscGraphDump.IRootFile",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".roots",
+                    expected: "Array<ITtscGraphDump.IRootFile>",
+                    value: input.roots
+                }, _errorFactory));
+                const _ao5 = (input, _path, _exceptionable = true) => _ap10(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable);
+                const _ao6 = (input, _path, _exceptionable = true) => ("string" === typeof input.config || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".config",
+                    expected: "string",
+                    value: input.config
+                }, _errorFactory)) && _ap10(input, _path, true && _exceptionable);
+                const _ao7 = (input, _path, _exceptionable = true) => _ap10(input, _path, true && _exceptionable) && ("string" === typeof input.checkerDigest || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".checkerDigest",
+                    expected: "string",
+                    value: input.checkerDigest
+                }, _errorFactory)) && ("string" === typeof input.diskDigest || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diskDigest",
+                    expected: "string",
+                    value: input.diskDigest
+                }, _errorFactory));
+                const _ao8 = (input, _path, _exceptionable = true) => _ap10(input, _path, true && _exceptionable) && ("number" === typeof input.line || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".line",
+                    expected: "number",
+                    value: input.line
+                }, _errorFactory)) && ("number" === typeof input.column || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".column",
+                    expected: "number",
+                    value: input.column
+                }, _errorFactory)) && ("number" === typeof input.code || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".code",
+                    expected: "number",
+                    value: input.code
+                }, _errorFactory)) && ("error" === input.category || "warning" === input.category || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".category",
+                    expected: "(\"error\" | \"warning\")",
+                    value: input.category
+                }, _errorFactory)) && ("string" === typeof input.message || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".message",
+                    expected: "string",
+                    value: input.message
+                }, _errorFactory));
+                const _ao9 = (input, _path, _exceptionable = true) => _ap12(input, _path, true && _exceptionable) && _ap13(input, _path, true && _exceptionable) && _ap14(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap15(input, _path, true && _exceptionable) && _ap16(input, _path, true && _exceptionable) && _ap17(input, _path, true && _exceptionable) && _ap18(input, _path, true && _exceptionable) && _ap19(input, _path, true && _exceptionable) && _ap20(input, _path, true && _exceptionable) && _ap21(input, _path, true && _exceptionable) && _ap22(input, _path, true && _exceptionable) && _ap23(input, _path, true && _exceptionable) && _ap24(input, _path, true && _exceptionable) && _ap25(input, _path, true && _exceptionable) && _ap26(input, _path, true && _exceptionable) && _ap27(input, _path, true && _exceptionable) && _ap28(input, _path, true && _exceptionable) && _ap29(input, _path, true && _exceptionable);
+                const _io0 = input => "number" === typeof input.id && _ip0(input) && ("error" === input.mode || "incremental" === input.mode || "initial" === input.mode || "rebuild" === input.mode || "reload" === input.mode || "unchanged" === input.mode) && _ip1(input) && "boolean" === typeof input.changed && (undefined === input.dump || "object" === typeof input.dump && null !== input.dump && _io1(input.dump)) && (undefined === input.snapshot || "object" === typeof input.snapshot && null !== input.snapshot && _io17(input.snapshot)) && (undefined === input.error || "string" === typeof input.error);
+                const _io1 = input => _ip2(input) && _ip3(input) && ("object" === typeof input.provenance && null !== input.provenance && _io2(input.provenance)) && _ip4(input) && _ip5(input) && _ip6(input);
+                const _io10 = input => _ip13(input) && (undefined === input.value || "string" === typeof input.value);
+                const _io11 = input => _ip13(input) && ("method" === input.kind || "property" === input.kind) && (undefined === input.line || "number" === typeof input.line) && _ip25(input);
+                const _io12 = input => _ip13(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io13(elem)));
+                const _io13 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
+                const _io14 = input => _ip13(input) && (undefined === input.text || "string" === typeof input.text);
+                const _io15 = input => (undefined === input.file || "string" === typeof input.file) && "number" === typeof input.startLine && (undefined === input.startCol || "number" === typeof input.startCol) && (undefined === input.endLine || "number" === typeof input.endLine) && (undefined === input.endCol || "number" === typeof input.endCol);
+                const _io16 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip28(input);
+                const _io17 = input => _ip0(input) && _ip7(input) && _ip2(input) && _ip3(input) && _ip8(input) && _ip1(input) && _ip9(input) && "number" === typeof input.sequence && "string" === typeof input.generation && (undefined === input.baseSequence || "number" === typeof input.baseSequence) && (undefined === input.baseGeneration || "string" === typeof input.baseGeneration) && (Array.isArray(input.upserts) && input.upserts.every(elem => "object" === typeof elem && null !== elem && _io18(elem))) && (Array.isArray(input.deletes) && input.deletes.every(elem => "string" === typeof elem)) && (Array.isArray(input.manifest) && input.manifest.every(elem => "object" === typeof elem && null !== elem && _io20(elem)));
+                const _io18 = input => _ip11(input) && ("object" === typeof input.shard && null !== input.shard && _io19(input.shard));
+                const _io19 = input => _ip30(input) && (undefined === input.source || "object" === typeof input.source && null !== input.source && _io7(input.source)) && (undefined === input.config || "object" === typeof input.config && null !== input.config && _io5(input.config)) && _ip5(input) && _ip6(input) && _ip4(input);
+                const _io2 = input => _ip7(input) && _ip1(input) && _ip8(input) && (undefined === input.artifactProducer || "object" === typeof input.artifactProducer && null !== input.artifactProducer && _io3(input.artifactProducer)) && _ip9(input) && (Array.isArray(input.sources) && input.sources.every(elem => "object" === typeof elem && null !== elem && _io7(elem)));
+                const _io20 = input => _ip30(input) && _ip11(input);
+                const _io3 = input => "string" === typeof input.tool && "string" === typeof input.version && "string" === typeof input.typescript;
+                const _io4 = input => Array.isArray(input.configs) && input.configs.every(elem => "object" === typeof elem && null !== elem && _io5(elem)) && (Array.isArray(input.roots) && input.roots.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
+                const _io5 = input => _ip10(input) && _ip11(input);
+                const _io6 = input => "string" === typeof input.config && _ip10(input);
+                const _io7 = input => _ip10(input) && "string" === typeof input.checkerDigest && "string" === typeof input.diskDigest;
+                const _io8 = input => _ip10(input) && "number" === typeof input.line && "number" === typeof input.column && "number" === typeof input.code && ("error" === input.category || "warning" === input.category) && "string" === typeof input.message;
+                const _io9 = input => _ip12(input) && _ip13(input) && _ip14(input) && _ip10(input) && _ip15(input) && _ip16(input) && _ip17(input) && _ip18(input) && _ip19(input) && _ip20(input) && _ip21(input) && _ip22(input) && _ip23(input) && _ip24(input) && _ip25(input) && _ip26(input) && _ip27(input) && _ip28(input) && _ip29(input);
+                const __is = input => "object" === typeof input && null !== input && _io0(input);
+                let _errorFactory;
+                return (input, errorFactory) => {
+                    if (false === __is(input)) {
+                        _errorFactory = errorFactory;
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
+                            method: "typia.assert",
+                            path: _path + "",
+                            expected: "ITtscGraphSnapshot",
+                            value: input
+                        }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                            method: "typia.assert",
+                            path: _path + "",
+                            expected: "ITtscGraphSnapshot",
+                            value: input
+                        }, _errorFactory))(input, "$input", true);
+                    }
+                    return input;
+                };
+            })()(parsed);
+        }
+        catch (error) {
+            throw new Error(`@ttsc/graph: native session returned an unreadable response: ${asError(error).message}`);
+        }
+        return response;
+    }
+    TtscGraphProtocol.decode = decode;
+})(TtscGraphProtocol || (exports.TtscGraphProtocol = TtscGraphProtocol = {}));
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+//# sourceMappingURL=TtscGraphProtocol.js.map