@selvajs/solve 2.0.0-beta.8 → 2.0.0

package/dist/outcome-DNrffAXp.js

@@ -0,0 +1,169 @@
+// src/shared/solve-fn.ts
+/**
+* The solve contract — what a solve returns and what a caller supplies to run one.
+*
+* Lives in `shared/` because both halves of the package speak it: `client/` calls a `SolveFn` and
+* stores its `SolveResult`; `server/` produces the payload one is built from.
+*/
+/**
+* Marker the Grasshopper Message component prepends to a blocking error.
+*
+* Rhino.Compute flattens runtime messages to plain strings with no component attribution, so
+* this is the only way that path can tell a deliberate block from any other solve error. The
+* local WebSocket path carries `isGate` structurally and does not need it — but the component
+* writes the marker unconditionally, because the same definition runs on both.
+*
+* Changing this string breaks blocking on deployed Selva for every already-published
+* definition, since the text is baked into the .gh file's solve output, not the plugin.
+*/
+const SOLVE_BLOCKED_MARKER = "[Selva:blocked]";
+/**
+* Marker the Message component prepends to a remark or warning — the non-blocking levels.
+*
+* Same reason as `SOLVE_BLOCKED_MARKER`: on Rhino.Compute nothing structural survives, and the
+* UI has to tell a message the author chose to write from an incidental Grasshopper warning.
+* Definitions saved before this existed lack it, so the reader falls back to the component name.
+*/
+const SOLVE_AUTHORED_MARKER = "[Selva:msg]";
+/**
+* Marker for an authored message whose author chose Notify = Log.
+*
+* Still theirs — it keeps its attribution and its place in the message list — but it does not
+* interrupt. Errors never carry it: their result is withheld, so they always interrupt.
+*/
+const SOLVE_LOG_ONLY_MARKER = "[Selva:log]";
+// src/shared/compute-diagnostics.ts
+/**
+* Compute's per-message attribution suffix. Anchored to the end and requiring the parenthesised
+* GUID, so an author who writes `component "x"` mid-sentence keeps their text intact.
+*/
+const ATTRIBUTION = /:\s*component\s+"([^"]*)"\s*\(([0-9a-fA-F-]{36}|\.\.\.)\)\s*$/;
+/** The Selva Message component's own name, as `LogRuntimeMessages` reports it. */
+const MESSAGE_COMPONENT_NAME = "Message";
+/**
+* Splits one Compute message string into the author's text and its attribution.
+*
+* Leaves the text alone when the suffix is absent — an exception thrown by a script component
+* has no attribution and must not be truncated on a guess.
+*/
+function parseComputeMessage(raw) {
+	const blocked = raw.includes(SOLVE_BLOCKED_MARKER);
+	const logOnly = !blocked && raw.includes("[Selva:log]");
+	const authored = blocked || logOnly || raw.includes("[Selva:msg]");
+	let message = raw;
+	let source;
+	const attribution = ATTRIBUTION.exec(message);
+	if (attribution) {
+		source = attribution[1] || void 0;
+		message = message.slice(0, attribution.index);
+	}
+	if (authored) message = message.replace(SOLVE_BLOCKED_MARKER, "").replace(SOLVE_AUTHORED_MARKER, "").replace(SOLVE_LOG_ONLY_MARKER, "").replace(/^\s*\d+\.\s*Solution exception:\s*/, "");
+	return {
+		message: message.replace(/\s{2,}/g, " ").trim(),
+		source,
+		blocked,
+		authored,
+		logOnly
+	};
+}
+/**
+* Rebuilds structured diagnostics from Compute's `errors`/`warnings` arrays.
+*
+* `isGate` comes from the marker the component writes. The component-name fallback is for
+* definitions saved before the non-blocking marker existed; `obj.Name` is the component's type
+* name, not its nickname, so renaming one on the canvas cannot change how it behaves.
+*/
+function parseComputeDiagnostics(errors, warnings) {
+	const build = (raw, level) => {
+		const { message, source, authored, logOnly } = parseComputeMessage(raw);
+		const isGate = (authored || source === MESSAGE_COMPONENT_NAME) && !logOnly;
+		return {
+			level,
+			message,
+			...source ? { source } : {},
+			...isGate ? { isGate } : {}
+		};
+	};
+	return [...errors.map((raw) => build(raw, "error")), ...warnings.map((raw) => build(raw, "warning"))];
+}
+// src/shared/outcome.ts
+function isLevel(value) {
+	return value === "error" || value === "warning" || value === "remark";
+}
+/**
+* One wire diagnostic, normalized: an unknown level reads as a remark, text is trimmed, and
+* `source`/`isGate` are omitted rather than null or false. Null when it carries no message.
+*/
+function decodeDiagnostic(entry) {
+	if (!entry || typeof entry !== "object") return null;
+	const d = entry;
+	const message = typeof d.message === "string" ? d.message.trim() : "";
+	if (!message) return null;
+	const source = typeof d.source === "string" && d.source ? d.source : void 0;
+	return {
+		level: isLevel(d.level) ? d.level : "remark",
+		message,
+		...source ? { source } : {},
+		...d.isGate === true ? { isGate: true } : {}
+	};
+}
+function normalizeOutcome(entries, blocked, aborted) {
+	const seen = /* @__PURE__ */ new Set();
+	const diagnostics = [];
+	for (const entry of entries) {
+		const d = decodeDiagnostic(entry);
+		if (!d) continue;
+		const key = `${d.level}\u0000${d.message}\u0000${d.source ?? ""}\u0000${d.isGate === true}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		diagnostics.push(d);
+	}
+	return {
+		diagnostics,
+		blocked: blocked || aborted,
+		aborted
+	};
+}
+/**
+* Normalizes a wire outcome with `decodeDiagnostic`, dropping exact repeats, so the same verdict
+* decodes to the same object from either transport. Null when `wire` is not an outcome at all;
+* the caller then falls back. A verdict without a diagnostic list still counts: reading a refusal
+* as "no outcome" would let the solve through.
+*/
+function decodeOutcome(wire) {
+	if (!wire || typeof wire !== "object") return null;
+	const { diagnostics, blocked, aborted } = wire;
+	const hasList = Array.isArray(diagnostics);
+	if (!hasList && blocked === void 0 && aborted === void 0) return null;
+	const isTrue = (flag) => flag === true || flag === "true";
+	return normalizeOutcome(hasList ? diagnostics : [], isTrue(blocked), isTrue(aborted));
+}
+/** The legacy verdict, read from Compute's flattened `errors`/`warnings` and their markers. */
+function outcomeFromComputeMessages(errors, warnings) {
+	const strings = (list) => list.filter((m) => typeof m === "string");
+	const errorText = strings(errors);
+	return normalizeOutcome(parseComputeDiagnostics(errorText, strings(warnings)), errorText.some((e) => e.includes(SOLVE_BLOCKED_MARKER)), false);
+}
+/**
+* Builds the result a driver reports. A blocked or aborted outcome is "no result" whatever the
+* transport sent along: no outputs, no `source` (it holds the withheld outputs), and an empty mesh
+* list so the viewer clears. `errors` and `warnings` are derived from the diagnostics for hosts
+* that only want text.
+*/
+function finalizeResult(partial, outcome) {
+	const rejected = outcome.blocked || outcome.aborted;
+	const meshes = rejected ? [] : partial.meshes;
+	return {
+		outputs: rejected ? {} : partial.outputs,
+		...meshes !== void 0 ? { meshes } : {},
+		errors: outcome.diagnostics.filter((d) => d.level === "error").map((d) => d.message),
+		warnings: outcome.diagnostics.filter((d) => d.level === "warning").map((d) => d.message),
+		diagnostics: outcome.diagnostics,
+		blocked: outcome.blocked,
+		aborted: outcome.aborted,
+		...partial.source !== void 0 && !rejected ? { source: partial.source } : {}
+	};
+}
+export { outcomeFromComputeMessages as i, decodeOutcome as n, finalizeResult as r, decodeDiagnostic as t };
+
+//# sourceMappingURL=outcome-DNrffAXp.js.map

package/dist/outcome-DNrffAXp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome-DNrffAXp.js","names":[],"sources":["../src/shared/solve-fn.ts","../src/shared/compute-diagnostics.ts","../src/shared/outcome.ts"],"sourcesContent":["import type { SolveDiagnostic } from '@selvajs/schemas';\n\n/**\n * The solve contract — what a solve returns and what a caller supplies to run one.\n *\n * Lives in `shared/` because both halves of the package speak it: `client/` calls a `SolveFn` and\n * stores its `SolveResult`; `server/` produces the payload one is built from.\n */\n\n/**\n * Marker the Grasshopper Message component prepends to a blocking error.\n *\n * Rhino.Compute flattens runtime messages to plain strings with no component attribution, so\n * this is the only way that path can tell a deliberate block from any other solve error. The\n * local WebSocket path carries `isGate` structurally and does not need it — but the component\n * writes the marker unconditionally, because the same definition runs on both.\n *\n * Changing this string breaks blocking on deployed Selva for every already-published\n * definition, since the text is baked into the .gh file's solve output, not the plugin.\n */\nexport const SOLVE_BLOCKED_MARKER = '[Selva:blocked]';\n\n/**\n * Marker the Message component prepends to a remark or warning — the non-blocking levels.\n *\n * Same reason as `SOLVE_BLOCKED_MARKER`: on Rhino.Compute nothing structural survives, and the\n * UI has to tell a message the author chose to write from an incidental Grasshopper warning.\n * Definitions saved before this existed lack it, so the reader falls back to the component name.\n */\nexport const SOLVE_AUTHORED_MARKER = '[Selva:msg]';\n\n/**\n * Marker for an authored message whose author chose Notify = Log.\n *\n * Still theirs — it keeps its attribution and its place in the message list — but it does not\n * interrupt. Errors never carry it: their result is withheld, so they always interrupt.\n */\nexport const SOLVE_LOG_ONLY_MARKER = '[Selva:log]';\n\n/**\n * One message a solve raised, with who raised it and whether it was deliberate (`isGate`).\n * Generated from `wire-schema.json`; both transports decode into it (see `outcome.ts`).\n */\nexport type { SolveDiagnostic };\n\n/**\n * `TMesh` is deliberately opaque and defaults to `unknown`: this package never inspects meshes, and\n * typing them would drag a renderer dependency into a package whose whole point is not having one.\n * The app that owns assembly (parse → `THREE.Object3D[]`) is the only place that knows the concrete\n * type, and it narrows by writing `SolveResult<THREE.Object3D>` at its own seam.\n */\nexport interface SolveResult<TMesh = unknown, TSource = unknown> {\n\toutputs: Record<string, unknown>;\n\tmeshes?: TMesh[];\n\terrors?: string[];\n\twarnings?: string[];\n\t/** Structured form of `errors`/`warnings`, including remarks. Absent from transports that report neither. */\n\tdiagnostics?: SolveDiagnostic[];\n\t/**\n\t * The definition refused this solve — a guard in the definition raised an error and its\n\t * outputs were withheld deliberately. Distinct from an errored solve that still returned\n\t * values, and from a transport failure: the solve ran and its answer is \"no\". Consumers\n\t * should show `errors` instead of treating the empty outputs as a result.\n\t */\n\tblocked?: boolean;\n\t/**\n\t * The solve was stopped before it finished. Always also `blocked`: what computed before\n\t * the stop is not a result. Absent from a transport that cannot tell.\n\t */\n\taborted?: boolean;\n\t/**\n\t * The unparsed payload this result was built from, passed through verbatim. Opaque here for the\n\t * same reason as `TMesh`: a consumer that must persist or re-submit exactly what it showed the\n\t * user narrows it at its own seam. Travels with the result through the driver's memo, so a\n\t * cached hit carries the source that produced it. Unlike `meshes` it needs no ownership policy —\n\t * it is inert data, not a GPU-backed handle.\n\t *\n\t * Supplied by the `SolveFn`, so it is present only when the one in use sets it\n\t * (`createComputeFetchSolveFn` does). A transport with no raw payload to hand back leaves it\n\t * absent — see `values` on telling absent from unsupported.\n\t */\n\tsource?: TSource;\n\t/**\n\t * The input set that produced this result, stamped by the driver rather than the `SolveFn` — a\n\t * memo hit never calls the `SolveFn`, so a consumer reading values captured inside it would pair\n\t * the on-screen result with whatever solved last. Keeping the pair atomic is the point: a commit\n\t * path holding a `SolveResult` cannot mismatch artifact and inputs.\n\t *\n\t * Present only from a driver that owns a request/response pair (`createRequestResponseDriver`).\n\t * A push driver cannot attribute an incoming frame to a request and must leave this absent\n\t * rather than guess — so `undefined` means \"this transport does not supply it\", not \"no solve\n\t * yet\", and a consumer that needs the pair requires a request/response driver. See `SolveDriver`.\n\t */\n\tvalues?: Record<string, unknown>;\n}\n\n/** Implementations should listen to `signal` and abort/clean up when it fires. */\nexport type SolveFn<TMesh = unknown, TSource = unknown> = (\n\tvalues: Record<string, unknown>,\n\tsignal: AbortSignal\n) => Promise<SolveResult<TMesh, TSource>>;\n","// Rhino.Compute reports runtime messages as flat strings, so everything the UI needs to tell a\n// deliberate message from incidental noise has to be recovered from the text. This is the one\n// place that parsing happens.\n//\n// Two decorations are applied by the server, in this order:\n//   \"<author's text>: component \\\"<Name>\\\" (<guid>)\"   — LogRuntimeMessages, every message\n//   \"<n>. Solution exception:<marker> ...\"              — the numbered-error wrapper\n// The local WebSocket path carries the same facts structurally and never comes through here.\n\nimport {\n\tSOLVE_AUTHORED_MARKER,\n\tSOLVE_BLOCKED_MARKER,\n\tSOLVE_LOG_ONLY_MARKER,\n\ttype SolveDiagnostic\n} from './solve-fn.js';\n\n/**\n * Compute's per-message attribution suffix. Anchored to the end and requiring the parenthesised\n * GUID, so an author who writes `component \"x\"` mid-sentence keeps their text intact.\n */\nconst ATTRIBUTION = /:\\s*component\\s+\"([^\"]*)\"\\s*\\(([0-9a-fA-F-]{36}|\\.\\.\\.)\\)\\s*$/;\n\n/** The Selva Message component's own name, as `LogRuntimeMessages` reports it. */\nconst MESSAGE_COMPONENT_NAME = 'Message';\n\nexport interface ParsedComputeMessage {\n\t/** The author's text, with the attribution suffix and any marker removed. */\n\tmessage: string;\n\t/** Component name from the attribution suffix, when present. */\n\tsource?: string;\n\t/** Carried the block marker: a Message component refused the solve. */\n\tblocked: boolean;\n\t/** Carried any marker: a Message component wrote this. */\n\tauthored: boolean;\n\t/** The author chose Notify = Log: list it, but do not interrupt. */\n\tlogOnly: boolean;\n}\n\n/**\n * Splits one Compute message string into the author's text and its attribution.\n *\n * Leaves the text alone when the suffix is absent — an exception thrown by a script component\n * has no attribution and must not be truncated on a guess.\n */\nexport function parseComputeMessage(raw: string): ParsedComputeMessage {\n\tconst blocked = raw.includes(SOLVE_BLOCKED_MARKER);\n\tconst logOnly = !blocked && raw.includes(SOLVE_LOG_ONLY_MARKER);\n\tconst authored = blocked || logOnly || raw.includes(SOLVE_AUTHORED_MARKER);\n\tlet message = raw;\n\n\tlet source: string | undefined;\n\tconst attribution = ATTRIBUTION.exec(message);\n\tif (attribution) {\n\t\tsource = attribution[1] || undefined;\n\t\tmessage = message.slice(0, attribution.index);\n\t}\n\n\tif (authored) {\n\t\tmessage = message\n\t\t\t.replace(SOLVE_BLOCKED_MARKER, '')\n\t\t\t.replace(SOLVE_AUTHORED_MARKER, '')\n\t\t\t.replace(SOLVE_LOG_ONLY_MARKER, '')\n\t\t\t// The numbered wrapper reads as noise next to the author's own sentence. Dropped only\n\t\t\t// when a marker proves the text is one of ours.\n\t\t\t.replace(/^\\s*\\d+\\.\\s*Solution exception:\\s*/, '');\n\t}\n\n\treturn { message: message.replace(/\\s{2,}/g, ' ').trim(), source, blocked, authored, logOnly };\n}\n\n/**\n * Rebuilds structured diagnostics from Compute's `errors`/`warnings` arrays.\n *\n * `isGate` comes from the marker the component writes. The component-name fallback is for\n * definitions saved before the non-blocking marker existed; `obj.Name` is the component's type\n * name, not its nickname, so renaming one on the canvas cannot change how it behaves.\n */\nexport function parseComputeDiagnostics(\n\terrors: readonly string[],\n\twarnings: readonly string[]\n): SolveDiagnostic[] {\n\tconst build = (raw: string, level: 'error' | 'warning'): SolveDiagnostic => {\n\t\tconst { message, source, authored, logOnly } = parseComputeMessage(raw);\n\t\tconst isGate = (authored || source === MESSAGE_COMPONENT_NAME) && !logOnly;\n\t\treturn { level, message, ...(source ? { source } : {}), ...(isGate ? { isGate } : {}) };\n\t};\n\treturn [\n\t\t...errors.map((raw) => build(raw, 'error')),\n\t\t...warnings.map((raw) => build(raw, 'warning'))\n\t];\n}\n","// The one place a solve's verdict becomes a `SolveResult`. The plugin decides the verdict\n// (`SolveOutcome`: diagnostics, blocked, aborted) once, and both transports carry it: the local\n// `outputs` envelope and the VektorNode fork's `selva` block. Each driver decodes it here, so a\n// rule about what a verdict means is written once rather than once per transport.\n//\n// A Compute response without a `selva` block (stock server, older plugin) falls back to\n// `outcomeFromComputeMessages`, which recovers what it can from the flattened strings. It cannot\n// see remarks or an abort.\n\nimport type { SolveOutcome } from '@selvajs/schemas';\nimport { parseComputeDiagnostics } from './compute-diagnostics.js';\nimport { SOLVE_BLOCKED_MARKER, type SolveDiagnostic, type SolveResult } from './solve-fn.js';\n\nexport type { SolveOutcome };\n\nfunction isLevel(value: unknown): value is SolveDiagnostic['level'] {\n\treturn value === 'error' || value === 'warning' || value === 'remark';\n}\n\n/**\n * One wire diagnostic, normalized: an unknown level reads as a remark, text is trimmed, and\n * `source`/`isGate` are omitted rather than null or false. Null when it carries no message.\n */\nexport function decodeDiagnostic(entry: unknown): SolveDiagnostic | null {\n\tif (!entry || typeof entry !== 'object') return null;\n\tconst d = entry as Record<string, unknown>;\n\tconst message = typeof d.message === 'string' ? d.message.trim() : '';\n\tif (!message) return null;\n\tconst source = typeof d.source === 'string' && d.source ? d.source : undefined;\n\treturn {\n\t\tlevel: isLevel(d.level) ? d.level : 'remark',\n\t\tmessage,\n\t\t...(source ? { source } : {}),\n\t\t...(d.isGate === true ? { isGate: true } : {})\n\t};\n}\n\nfunction normalizeOutcome(\n\tentries: readonly unknown[],\n\tblocked: boolean,\n\taborted: boolean\n): SolveOutcome {\n\tconst seen = new Set<string>();\n\tconst diagnostics: SolveDiagnostic[] = [];\n\tfor (const entry of entries) {\n\t\tconst d = decodeDiagnostic(entry);\n\t\tif (!d) continue;\n\t\tconst key = `${d.level}\\u0000${d.message}\\u0000${d.source ?? ''}\\u0000${d.isGate === true}`;\n\t\tif (seen.has(key)) continue;\n\t\tseen.add(key);\n\t\tdiagnostics.push(d);\n\t}\n\treturn { diagnostics, blocked: blocked || aborted, aborted };\n}\n\n/**\n * Normalizes a wire outcome with `decodeDiagnostic`, dropping exact repeats, so the same verdict\n * decodes to the same object from either transport. Null when `wire` is not an outcome at all;\n * the caller then falls back. A verdict without a diagnostic list still counts: reading a refusal\n * as \"no outcome\" would let the solve through.\n */\nexport function decodeOutcome(wire: unknown): SolveOutcome | null {\n\tif (!wire || typeof wire !== 'object') return null;\n\tconst { diagnostics, blocked, aborted } = wire as Record<string, unknown>;\n\tconst hasList = Array.isArray(diagnostics);\n\tif (!hasList && blocked === undefined && aborted === undefined) return null;\n\t// `'true'` too: a flag that arrives stringified must fail closed, not let a refusal through.\n\tconst isTrue = (flag: unknown) => flag === true || flag === 'true';\n\treturn normalizeOutcome(hasList ? diagnostics : [], isTrue(blocked), isTrue(aborted));\n}\n\n/** The legacy verdict, read from Compute's flattened `errors`/`warnings` and their markers. */\nexport function outcomeFromComputeMessages(\n\terrors: readonly unknown[],\n\twarnings: readonly unknown[]\n): SolveOutcome {\n\tconst strings = (list: readonly unknown[]) => list.filter((m) => typeof m === 'string');\n\tconst errorText = strings(errors);\n\treturn normalizeOutcome(\n\t\tparseComputeDiagnostics(errorText, strings(warnings)),\n\t\t// Substring, not prefix: the server numbers each entry (\"1. Solution exception: ...\").\n\t\terrorText.some((e) => e.includes(SOLVE_BLOCKED_MARKER)),\n\t\tfalse\n\t);\n}\n\n/**\n * Builds the result a driver reports. A blocked or aborted outcome is \"no result\" whatever the\n * transport sent along: no outputs, no `source` (it holds the withheld outputs), and an empty mesh\n * list so the viewer clears. `errors` and `warnings` are derived from the diagnostics for hosts\n * that only want text.\n */\nexport function finalizeResult<TMesh, TSource>(\n\tpartial: { outputs: Record<string, unknown>; meshes?: TMesh[]; source?: TSource },\n\toutcome: SolveOutcome\n): SolveResult<TMesh, TSource> {\n\tconst rejected = outcome.blocked || outcome.aborted;\n\tconst meshes = rejected ? [] : partial.meshes;\n\treturn {\n\t\toutputs: rejected ? {} : partial.outputs,\n\t\t...(meshes !== undefined ? { meshes } : {}),\n\t\terrors: outcome.diagnostics.filter((d) => d.level === 'error').map((d) => d.message),\n\t\twarnings: outcome.diagnostics.filter((d) => d.level === 'warning').map((d) => d.message),\n\t\tdiagnostics: outcome.diagnostics,\n\t\tblocked: outcome.blocked,\n\t\taborted: outcome.aborted,\n\t\t...(partial.source !== undefined && !rejected ? { source: partial.source } : {})\n\t};\n}\n"],"mappings":"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"}