semantifold 0.3.0 → 0.5.0

package/build/src/backends/stdlib-support.d.ts

@@ -0,0 +1,14 @@
+export type StdlibProviderTarget = "php" | "ruby" | "javascript" | "typescript";
+export type SupportSegment = {
+    when: (operations: Set<string>) => boolean;
+    text: string;
+};
+/**
+ * Generates the complete tree-shaken stdlib provider artifact content for one adopted target.
+ * @param {StdlibProviderTarget} language - Adopted target host provider.
+ * @param {readonly string[]} operations - Used canonical operations in contract order.
+ * @param {string} [module] - Qualified canonical module identity; omitted for the Task 034 probe.
+ * @returns {string} Complete provider source text.
+ */
+export declare function generateStdlibProviderContent(language: StdlibProviderTarget, operations: readonly string[], module?: string): string;
+//# sourceMappingURL=stdlib-support.d.ts.map

package/build/src/backends/stdlib-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdlib-support.d.ts","sourceRoot":"","sources":["../../../src/backends/stdlib-support.js"],"names":[],"mappings":"AAKG,YAAwD,oBAAoB,GAAlE,KAAK,GAAG,MAAM,GAAG,YAAY,GAAG,YAAY,CAAsB;AAC5E,YAAsE,cAAc,GAA1E;IAAC,IAAI,EAAE,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAgB;AAiMvF;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAL3C,oBAK2C,EAAE,UAAU,EAJvD,SAAS,MAAM,EAIwC,EAAE,MAAM,AAHvE,CACA,EADQ,MAG+D,GAF7D,MAAM,CA6BlB"}

package/build/src/backends/stdlib-support.js

@@ -0,0 +1,237 @@
+// @ts-check
+import { generateTask037PhpProviderContent } from "./php-stdlib-support.js";
+/**
+ * @typedef {"php" | "ruby" | "javascript" | "typescript"} StdlibProviderTarget
+ * @typedef {{when: (operations: Set<string>) => boolean, text: string}} SupportSegment
+ */
+/**
+ * Emits the protected native entry shims that portable code is allowed to call.
+ * @param {StdlibProviderTarget} language - Adopted target.
+ * @param {readonly string[]} operations - Used canonical operations in contract order.
+ * @returns {string[]} One shim line per used operation.
+ */
+function providerShims(language, operations) {
+    const prefix = `__semantifold_provider_${language}_`;
+    const shims = [];
+    for (const operation of operations) {
+        if (language == "php") {
+            if (operation == "probeEffect")
+                shims.push(`function ${prefix}probeEffect(string $label, int $value, bool $fail): int { return probeEffect($label, $value, $fail); }`);
+            else if (operation == "probeAcquire")
+                shims.push(`function ${prefix}probeAcquire(bool $fail): ProbeResource { return probeAcquire($fail); }`);
+            else if (operation == "probeRead")
+                shims.push(`function ${prefix}probeRead(ProbeResource $resource, bool $fail): ?string { return probeRead($resource, $fail); }`);
+            else if (operation == "probeClose")
+                shims.push(`function ${prefix}probeClose(ProbeResource $resource, bool $fail): void { probeClose($resource, $fail); }`);
+            else
+                shims.push(`function ${prefix}probeTrace(): string { return probeTrace(); }`);
+        }
+        else if (language == "ruby") {
+            const parameter = operation == "probeEffect" ? "label, value, fail_value"
+                : operation == "probeAcquire" ? "fail_value"
+                    : operation == "probeTrace" ? "" : "resource, fail_value";
+            const call = operation == "probeEffect" ? "probeEffect(label, value, fail_value)"
+                : operation == "probeAcquire" ? "probeAcquire(fail_value)"
+                    : operation == "probeTrace" ? "probeTrace()" : `${operation}(resource, fail_value)`;
+            shims.push(`def ${prefix}${operation}(${parameter})\n  ${call}\nend`);
+        }
+        else if (language == "javascript") {
+            const parameters = operation == "probeEffect" ? "label, value, fail"
+                : operation == "probeAcquire" ? "fail"
+                    : operation == "probeTrace" ? "" : "resource, fail";
+            const body = operation == "probeEffect" ? "return probeEffect(label, value, fail)"
+                : operation == "probeAcquire" ? "return probeAcquire(fail)"
+                    : operation == "probeTrace" ? "return probeTrace()"
+                        : operation == "probeClose" ? "probeClose(resource, fail)" : "return probeRead(resource, fail)";
+            shims.push(`export function ${prefix}${operation}(${parameters}) { ${body} }`);
+        }
+        else {
+            const signature = operation == "probeEffect" ? "(label: string, value: number, fail: boolean): number"
+                : operation == "probeAcquire" ? "(fail: boolean): ProbeResource"
+                    : operation == "probeTrace" ? "(): string"
+                        : operation == "probeClose" ? "(resource: ProbeResource, fail: boolean): void" : "(resource: ProbeResource, fail: boolean): string | null";
+            const body = operation == "probeEffect" ? "return probeEffect(label, value, fail)"
+                : operation == "probeAcquire" ? "return probeAcquire(fail)"
+                    : operation == "probeTrace" ? "return probeTrace()"
+                        : operation == "probeClose" ? "probeClose(resource, fail)" : "return probeRead(resource, fail)";
+            shims.push(`export function ${prefix}${operation}${signature} { ${body} }`);
+        }
+    }
+    return shims;
+}
+/**
+ * Returns the ordered tree-shakable support segments for one adopted target.
+ * The full operation set reproduces the single-module support carrier byte-for-byte.
+ * @param {StdlibProviderTarget} language - Adopted target.
+ * @returns {SupportSegment[]} Ordered segments.
+ */
+function supportSegments(language) {
+    const any = () => true;
+    /**
+     * Reports whether any resource-lifecycle operation is used.
+     * @param {Set<string>} operations - Used operations.
+     * @returns {boolean} Whether a resource operation is used.
+     */
+    const resource = (operations) => operations.has("probeAcquire") || operations.has("probeRead") || operations.has("probeClose");
+    if (language == "php")
+        return [
+            { when: (operations) => operations.has("probeEffect"), text: "final class ProbeOperationFailure extends RuntimeException {}\n" },
+            { when: (operations) => operations.has("probeAcquire"), text: "final class ProbeAcquireFailure extends RuntimeException {}\n" },
+            { when: (operations) => operations.has("probeRead"), text: "final class ProbeReadFailure extends RuntimeException {}\n" },
+            { when: (operations) => operations.has("probeClose"), text: "final class ProbeCloseFailure extends RuntimeException {}\n" },
+            { when: (operations) => operations.has("probeRead") || operations.has("probeClose"), text: "final class ProbeResourceClosed extends RuntimeException {}\n" },
+            {
+                when: resource,
+                text: "final class ProbeResource {\n    public bool $closed = false;\n    public function __construct(public mixed $handle) {}\n}\n"
+            },
+            { when: any, text: "$GLOBALS['__semantifold_task034_trace'] = [];\n" },
+            {
+                when: (operations) => operations.has("probeEffect"),
+                text: "function probeEffect(string $label, int $value, bool $fail): int {\n    $GLOBALS['__semantifold_task034_trace'][] = 'effect:' . $label;\n    if ($fail) throw new ProbeOperationFailure('ProbeOperationFailure');\n    return $value;\n}\n"
+            },
+            {
+                when: (operations) => operations.has("probeAcquire"),
+                text: "function probeAcquire(bool $fail): ProbeResource {\n    $GLOBALS['__semantifold_task034_trace'][] = 'acquire';\n    if ($fail) throw new ProbeAcquireFailure('ProbeAcquireFailure');\n    try { $handle = @fopen((string) getenv('SEMANTIFOLD_TASK034_PROBE_PATH'), 'rb'); }\n    catch (Throwable) { throw new ProbeAcquireFailure('ProbeAcquireFailure'); }\n    if ($handle === false) throw new ProbeAcquireFailure('ProbeAcquireFailure');\n    return new ProbeResource($handle);\n}\n"
+            },
+            {
+                when: (operations) => operations.has("probeRead"),
+                text: "function probeRead(ProbeResource $resource, bool $fail): ?string {\n    if ($resource->closed) throw new ProbeResourceClosed('ProbeResourceClosed');\n    $GLOBALS['__semantifold_task034_trace'][] = 'read';\n    if ($fail) throw new ProbeReadFailure('ProbeReadFailure');\n    try { $line = @fgets($resource->handle); }\n    catch (Throwable) { throw new ProbeReadFailure('ProbeReadFailure'); }\n    if ($line === false) {\n        if (feof($resource->handle)) return null;\n        throw new ProbeReadFailure('ProbeReadFailure');\n    }\n    return rtrim($line, \"\\r\\n\");\n}\n"
+            },
+            {
+                when: (operations) => operations.has("probeClose"),
+                text: "function probeClose(ProbeResource $resource, bool $fail): void {\n    if ($resource->closed) throw new ProbeResourceClosed('ProbeResourceClosed');\n    $GLOBALS['__semantifold_task034_trace'][] = 'close';\n    try { $closed = @fclose($resource->handle); }\n    catch (Throwable) { $resource->closed = true; throw new ProbeCloseFailure('ProbeCloseFailure'); }\n    $resource->closed = true;\n    if ($fail || !$closed) throw new ProbeCloseFailure('ProbeCloseFailure');\n}\n"
+            },
+            {
+                when: (operations) => operations.has("probeTrace"),
+                text: "function probeTrace(): string { return implode(',', $GLOBALS['__semantifold_task034_trace']); }\n"
+            }
+        ];
+    if (language == "ruby")
+        return [
+            { when: (operations) => operations.has("probeEffect"), text: "class ProbeOperationFailure < StandardError; end\n" },
+            { when: (operations) => operations.has("probeAcquire"), text: "class ProbeAcquireFailure < StandardError; end\n" },
+            { when: (operations) => operations.has("probeRead"), text: "class ProbeReadFailure < StandardError; end\n" },
+            { when: (operations) => operations.has("probeClose"), text: "class ProbeCloseFailure < StandardError; end\n" },
+            { when: (operations) => operations.has("probeRead") || operations.has("probeClose"), text: "class ProbeResourceClosed < StandardError; end\n" },
+            {
+                when: resource,
+                text: "class ProbeResource\n  attr_accessor :handle, :closed\n  def initialize(handle); @handle = handle; @closed = false; end\nend\n"
+            },
+            { when: any, text: "$__semantifold_task034_trace = []\n" },
+            {
+                when: (operations) => operations.has("probeEffect"),
+                text: "def probeEffect(label, value, fail_value)\n  $__semantifold_task034_trace << \"effect:#{label}\"\n  raise ProbeOperationFailure, \"ProbeOperationFailure\" if fail_value\n  value\nend\n"
+            },
+            {
+                when: (operations) => operations.has("probeAcquire"),
+                text: "def probeAcquire(fail_value)\n  $__semantifold_task034_trace << \"acquire\"\n  raise ProbeAcquireFailure, \"ProbeAcquireFailure\" if fail_value\n  begin; ProbeResource.new(File.open(ENV.fetch(\"SEMANTIFOLD_TASK034_PROBE_PATH\"), \"r\")); rescue ProbeAcquireFailure; raise; rescue StandardError; raise ProbeAcquireFailure, \"ProbeAcquireFailure\"; end\nend\n"
+            },
+            {
+                when: (operations) => operations.has("probeRead"),
+                text: "def probeRead(resource, fail_value)\n  raise ProbeResourceClosed, \"ProbeResourceClosed\" if resource.closed\n  $__semantifold_task034_trace << \"read\"\n  raise ProbeReadFailure, \"ProbeReadFailure\" if fail_value\n  begin; value = resource.handle.gets; value.nil? ? nil : value.chomp; rescue ProbeReadFailure; raise; rescue StandardError; raise ProbeReadFailure, \"ProbeReadFailure\"; end\nend\n"
+            },
+            {
+                when: (operations) => operations.has("probeClose"),
+                text: "def probeClose(resource, fail_value)\n  raise ProbeResourceClosed, \"ProbeResourceClosed\" if resource.closed\n  $__semantifold_task034_trace << \"close\"\n  begin; resource.handle.close; rescue StandardError; resource.closed = true; raise ProbeCloseFailure, \"ProbeCloseFailure\"; end\n  resource.closed = true\n  raise ProbeCloseFailure, \"ProbeCloseFailure\" if fail_value\n  nil\nend\n"
+            },
+            { when: (operations) => operations.has("probeTrace"), text: "def probeTrace; $__semantifold_task034_trace.join(\",\"); end\n" }
+        ];
+    const fs = /** @type {SupportSegment} */ ({ when: (operations) => operations.has("probeAcquire"), text: 'const __semantifoldTask034Fs = process.getBuiltinModule("node:fs")\n' });
+    const trace = language == "javascript"
+        ? { when: any, text: "const __semantifoldTask034Trace = []\n" }
+        : { when: any, text: "const __semantifoldTask034Trace: string[] = []\n" };
+    const resourceClass = language == "javascript"
+        ? { when: resource, text: "class ProbeResource { constructor(handle) { this.handle = handle; this.closed = false; this.position = 0 } }\n" }
+        : { when: resource, text: "class ProbeResource { closed = false; position = 0; constructor(readonly handle: number) {} }\n" };
+    if (language == "javascript")
+        return [
+            fs,
+            { when: (operations) => operations.has("probeEffect"), text: "class ProbeOperationFailure extends Error {}\n" },
+            { when: (operations) => operations.has("probeAcquire"), text: "class ProbeAcquireFailure extends Error {}\n" },
+            { when: (operations) => operations.has("probeRead"), text: "class ProbeReadFailure extends Error {}\n" },
+            { when: (operations) => operations.has("probeClose"), text: "class ProbeCloseFailure extends Error {}\n" },
+            { when: (operations) => operations.has("probeRead") || operations.has("probeClose"), text: "class ProbeResourceClosed extends Error {}\n" },
+            resourceClass,
+            trace,
+            {
+                when: (operations) => operations.has("probeEffect"),
+                text: 'function probeEffect(label, value, fail) { __semantifoldTask034Trace.push(`effect:${label}`); if (fail) throw new ProbeOperationFailure("ProbeOperationFailure"); return value }\n'
+            },
+            {
+                when: (operations) => operations.has("probeAcquire"),
+                text: 'function probeAcquire(fail) { __semantifoldTask034Trace.push("acquire"); if (fail) throw new ProbeAcquireFailure("ProbeAcquireFailure"); try { return new ProbeResource(__semantifoldTask034Fs.openSync(process.env.SEMANTIFOLD_TASK034_PROBE_PATH, "r")) } catch { throw new ProbeAcquireFailure("ProbeAcquireFailure") } }\n'
+            },
+            {
+                when: (operations) => operations.has("probeRead"),
+                text: 'function probeRead(resource, fail) { if (resource.closed) throw new ProbeResourceClosed("ProbeResourceClosed"); __semantifoldTask034Trace.push("read"); if (fail) throw new ProbeReadFailure("ProbeReadFailure"); try { const bytes = []; const buffer = Buffer.alloc(1); while (true) { const count = __semantifoldTask034Fs.readSync(resource.handle, buffer, 0, 1, resource.position++); if (count === 0) return bytes.length === 0 ? null : Buffer.from(bytes).toString("utf8"); if (buffer[0] === 10) return Buffer.from(bytes).toString("utf8").replace(/\\r$/u, ""); bytes.push(buffer[0]) } } catch { throw new ProbeReadFailure("ProbeReadFailure") } }\n'
+            },
+            {
+                when: (operations) => operations.has("probeClose"),
+                text: 'function probeClose(resource, fail) { if (resource.closed) throw new ProbeResourceClosed("ProbeResourceClosed"); __semantifoldTask034Trace.push("close"); try { __semantifoldTask034Fs.closeSync(resource.handle) } catch { resource.closed = true; throw new ProbeCloseFailure("ProbeCloseFailure") } resource.closed = true; if (fail) throw new ProbeCloseFailure("ProbeCloseFailure") }\n'
+            },
+            { when: (operations) => operations.has("probeTrace"), text: 'function probeTrace() { return __semantifoldTask034Trace.join(",") }\n' }
+        ];
+    return [
+        fs,
+        { when: (operations) => operations.has("probeEffect"), text: "class ProbeOperationFailure extends Error {}\n" },
+        { when: (operations) => operations.has("probeAcquire"), text: "class ProbeAcquireFailure extends Error {}\n" },
+        { when: (operations) => operations.has("probeRead"), text: "class ProbeReadFailure extends Error {}\n" },
+        { when: (operations) => operations.has("probeClose"), text: "class ProbeCloseFailure extends Error {}\n" },
+        { when: (operations) => operations.has("probeRead") || operations.has("probeClose"), text: "class ProbeResourceClosed extends Error {}\n" },
+        resourceClass,
+        trace,
+        {
+            when: (operations) => operations.has("probeEffect"),
+            text: 'function probeEffect(label: string, value: number, fail: boolean): number { __semantifoldTask034Trace.push(`effect:${label}`); if (fail) throw new ProbeOperationFailure("ProbeOperationFailure"); return value }\n'
+        },
+        {
+            when: (operations) => operations.has("probeAcquire"),
+            text: 'function probeAcquire(fail: boolean): ProbeResource { __semantifoldTask034Trace.push("acquire"); if (fail) throw new ProbeAcquireFailure("ProbeAcquireFailure"); try { return new ProbeResource(__semantifoldTask034Fs.openSync(process.env.SEMANTIFOLD_TASK034_PROBE_PATH as string, "r")) } catch { throw new ProbeAcquireFailure("ProbeAcquireFailure") } }\n'
+        },
+        {
+            when: (operations) => operations.has("probeRead"),
+            text: 'function probeRead(resource: ProbeResource, fail: boolean): string | null { if (resource.closed) throw new ProbeResourceClosed("ProbeResourceClosed"); __semantifoldTask034Trace.push("read"); if (fail) throw new ProbeReadFailure("ProbeReadFailure"); try { const bytes: number[] = []; const buffer = Buffer.alloc(1); while (true) { const count = __semantifoldTask034Fs.readSync(resource.handle, buffer, 0, 1, resource.position++); if (count === 0) return bytes.length === 0 ? null : Buffer.from(bytes).toString("utf8"); if (buffer[0] === 10) return Buffer.from(bytes).toString("utf8").replace(/\\r$/u, ""); bytes.push(buffer[0]) } } catch { throw new ProbeReadFailure("ProbeReadFailure") } }\n'
+        },
+        {
+            when: (operations) => operations.has("probeClose"),
+            text: 'function probeClose(resource: ProbeResource, fail: boolean): void { if (resource.closed) throw new ProbeResourceClosed("ProbeResourceClosed"); __semantifoldTask034Trace.push("close"); try { __semantifoldTask034Fs.closeSync(resource.handle) } catch { resource.closed = true; throw new ProbeCloseFailure("ProbeCloseFailure") } resource.closed = true; if (fail) throw new ProbeCloseFailure("ProbeCloseFailure") }\n'
+        },
+        { when: (operations) => operations.has("probeTrace"), text: 'function probeTrace(): string { return __semantifoldTask034Trace.join(",") }\n' }
+    ];
+}
+/**
+ * Generates the complete tree-shaken stdlib provider artifact content for one adopted target.
+ * @param {StdlibProviderTarget} language - Adopted target host provider.
+ * @param {readonly string[]} operations - Used canonical operations in contract order.
+ * @param {string} [module] - Qualified canonical module identity; omitted for the Task 034 probe.
+ * @returns {string} Complete provider source text.
+ */
+export function generateStdlibProviderContent(language, operations, module) {
+    if (module !== undefined && module != "semantifold.task034.resource-probe") {
+        if (language != "php")
+            throw new RangeError(`Canonical module '${module}' has no '${language}' provider content.`);
+        return generateTask037PhpProviderContent(module, operations);
+    }
+    const used = new Set(operations);
+    if (used.size == 0)
+        throw new Error("A stdlib provider requires at least one used operation.");
+    const segments = supportSegments(language);
+    const start = language == "ruby" ? "# semantifold-task034-support\n" : "/* semantifold-task034-support */\n";
+    const end = language == "ruby" ? "# semantifold-task034-support-end\n\n" : "/* semantifold-task034-support-end */\n\n";
+    const support = start +
+        segments.filter(({ when }) => when(used)).map(({ text }) => text).join("") +
+        end;
+    const header = language == "php" ? "<?php\ndeclare(strict_types=1);\n" : "";
+    const classExports = language == "javascript" || language == "typescript" ?
+        `export {${[
+            ["ProbeOperationFailure", used.has("probeEffect")],
+            ["ProbeAcquireFailure", used.has("probeAcquire")],
+            ["ProbeReadFailure", used.has("probeRead")],
+            ["ProbeCloseFailure", used.has("probeClose")],
+            ["ProbeResourceClosed", used.has("probeRead") || used.has("probeClose")],
+            ["ProbeResource", used.has("probeAcquire") || used.has("probeRead") || used.has("probeClose")]
+        ].filter(([, present]) => present).map(([name]) => name).join(", ")}}\n` : "";
+    const shims = providerShims(language, operations);
+    return header + support + classExports + (shims.length > 0 ? shims.join("\n") + "\n" : "");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stdlib-support.js","sourceRoot":"","sources":["../../../src/backends/stdlib-support.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {generateTask037PhpProviderContent} from \"./php-stdlib-support.js\"\n\n/**\n * @typedef {\"php\" | \"ruby\" | \"javascript\" | \"typescript\"} StdlibProviderTarget\n * @typedef {{when: (operations: Set<string>) => boolean, text: string}} SupportSegment\n */\n\n/**\n * Emits the protected native entry shims that portable code is allowed to call.\n * @param {StdlibProviderTarget} language - Adopted target.\n * @param {readonly string[]} operations - Used canonical operations in contract order.\n * @returns {string[]} One shim line per used operation.\n */\nfunction providerShims(language, operations) {\n  const prefix = `__semantifold_provider_${language}_`\n  const shims = []\n\n  for (const operation of operations) {\n    if (language == \"php\") {\n      if (operation == \"probeEffect\") shims.push(`function ${prefix}probeEffect(string $label, int $value, bool $fail): int { return probeEffect($label, $value, $fail); }`)\n      else if (operation == \"probeAcquire\") shims.push(`function ${prefix}probeAcquire(bool $fail): ProbeResource { return probeAcquire($fail); }`)\n      else if (operation == \"probeRead\") shims.push(`function ${prefix}probeRead(ProbeResource $resource, bool $fail): ?string { return probeRead($resource, $fail); }`)\n      else if (operation == \"probeClose\") shims.push(`function ${prefix}probeClose(ProbeResource $resource, bool $fail): void { probeClose($resource, $fail); }`)\n      else shims.push(`function ${prefix}probeTrace(): string { return probeTrace(); }`)\n    } else if (language == \"ruby\") {\n      const parameter = operation == \"probeEffect\" ? \"label, value, fail_value\"\n        : operation == \"probeAcquire\" ? \"fail_value\"\n          : operation == \"probeTrace\" ? \"\" : \"resource, fail_value\"\n      const call = operation == \"probeEffect\" ? \"probeEffect(label, value, fail_value)\"\n        : operation == \"probeAcquire\" ? \"probeAcquire(fail_value)\"\n          : operation == \"probeTrace\" ? \"probeTrace()\" : `${operation}(resource, fail_value)`\n      shims.push(`def ${prefix}${operation}(${parameter})\\n  ${call}\\nend`)\n    } else if (language == \"javascript\") {\n      const parameters = operation == \"probeEffect\" ? \"label, value, fail\"\n        : operation == \"probeAcquire\" ? \"fail\"\n          : operation == \"probeTrace\" ? \"\" : \"resource, fail\"\n      const body = operation == \"probeEffect\" ? \"return probeEffect(label, value, fail)\"\n        : operation == \"probeAcquire\" ? \"return probeAcquire(fail)\"\n          : operation == \"probeTrace\" ? \"return probeTrace()\"\n            : operation == \"probeClose\" ? \"probeClose(resource, fail)\" : \"return probeRead(resource, fail)\"\n      shims.push(`export function ${prefix}${operation}(${parameters}) { ${body} }`)\n    } else {\n      const signature = operation == \"probeEffect\" ? \"(label: string, value: number, fail: boolean): number\"\n        : operation == \"probeAcquire\" ? \"(fail: boolean): ProbeResource\"\n          : operation == \"probeTrace\" ? \"(): string\"\n            : operation == \"probeClose\" ? \"(resource: ProbeResource, fail: boolean): void\" : \"(resource: ProbeResource, fail: boolean): string | null\"\n      const body = operation == \"probeEffect\" ? \"return probeEffect(label, value, fail)\"\n        : operation == \"probeAcquire\" ? \"return probeAcquire(fail)\"\n          : operation == \"probeTrace\" ? \"return probeTrace()\"\n            : operation == \"probeClose\" ? \"probeClose(resource, fail)\" : \"return probeRead(resource, fail)\"\n      shims.push(`export function ${prefix}${operation}${signature} { ${body} }`)\n    }\n  }\n  return shims\n}\n\n/**\n * Returns the ordered tree-shakable support segments for one adopted target.\n * The full operation set reproduces the single-module support carrier byte-for-byte.\n * @param {StdlibProviderTarget} language - Adopted target.\n * @returns {SupportSegment[]} Ordered segments.\n */\nfunction supportSegments(language) {\n  const any = () => true\n\n  /**\n   * Reports whether any resource-lifecycle operation is used.\n   * @param {Set<string>} operations - Used operations.\n   * @returns {boolean} Whether a resource operation is used.\n   */\n  const resource = (operations) => operations.has(\"probeAcquire\") || operations.has(\"probeRead\") || operations.has(\"probeClose\")\n\n  if (language == \"php\") return [\n    {when: (operations) => operations.has(\"probeEffect\"), text: \"final class ProbeOperationFailure extends RuntimeException {}\\n\"},\n    {when: (operations) => operations.has(\"probeAcquire\"), text: \"final class ProbeAcquireFailure extends RuntimeException {}\\n\"},\n    {when: (operations) => operations.has(\"probeRead\"), text: \"final class ProbeReadFailure extends RuntimeException {}\\n\"},\n    {when: (operations) => operations.has(\"probeClose\"), text: \"final class ProbeCloseFailure extends RuntimeException {}\\n\"},\n    {when: (operations) => operations.has(\"probeRead\") || operations.has(\"probeClose\"), text: \"final class ProbeResourceClosed extends RuntimeException {}\\n\"},\n    {\n      when: resource,\n      text: \"final class ProbeResource {\\n    public bool $closed = false;\\n    public function __construct(public mixed $handle) {}\\n}\\n\"\n    },\n    {when: any, text: \"$GLOBALS['__semantifold_task034_trace'] = [];\\n\"},\n    {\n      when: (operations) => operations.has(\"probeEffect\"),\n      text: \"function probeEffect(string $label, int $value, bool $fail): int {\\n    $GLOBALS['__semantifold_task034_trace'][] = 'effect:' . $label;\\n    if ($fail) throw new ProbeOperationFailure('ProbeOperationFailure');\\n    return $value;\\n}\\n\"\n    },\n    {\n      when: (operations) => operations.has(\"probeAcquire\"),\n      text: \"function probeAcquire(bool $fail): ProbeResource {\\n    $GLOBALS['__semantifold_task034_trace'][] = 'acquire';\\n    if ($fail) throw new ProbeAcquireFailure('ProbeAcquireFailure');\\n    try { $handle = @fopen((string) getenv('SEMANTIFOLD_TASK034_PROBE_PATH'), 'rb'); }\\n    catch (Throwable) { throw new ProbeAcquireFailure('ProbeAcquireFailure'); }\\n    if ($handle === false) throw new ProbeAcquireFailure('ProbeAcquireFailure');\\n    return new ProbeResource($handle);\\n}\\n\"\n    },\n    {\n      when: (operations) => operations.has(\"probeRead\"),\n      text: \"function probeRead(ProbeResource $resource, bool $fail): ?string {\\n    if ($resource->closed) throw new ProbeResourceClosed('ProbeResourceClosed');\\n    $GLOBALS['__semantifold_task034_trace'][] = 'read';\\n    if ($fail) throw new ProbeReadFailure('ProbeReadFailure');\\n    try { $line = @fgets($resource->handle); }\\n    catch (Throwable) { throw new ProbeReadFailure('ProbeReadFailure'); }\\n    if ($line === false) {\\n        if (feof($resource->handle)) return null;\\n        throw new ProbeReadFailure('ProbeReadFailure');\\n    }\\n    return rtrim($line, \\\"\\\\r\\\\n\\\");\\n}\\n\"\n    },\n    {\n      when: (operations) => operations.has(\"probeClose\"),\n      text: \"function probeClose(ProbeResource $resource, bool $fail): void {\\n    if ($resource->closed) throw new ProbeResourceClosed('ProbeResourceClosed');\\n    $GLOBALS['__semantifold_task034_trace'][] = 'close';\\n    try { $closed = @fclose($resource->handle); }\\n    catch (Throwable) { $resource->closed = true; throw new ProbeCloseFailure('ProbeCloseFailure'); }\\n    $resource->closed = true;\\n    if ($fail || !$closed) throw new ProbeCloseFailure('ProbeCloseFailure');\\n}\\n\"\n    },\n    {\n      when: (operations) => operations.has(\"probeTrace\"),\n      text: \"function probeTrace(): string { return implode(',', $GLOBALS['__semantifold_task034_trace']); }\\n\"\n    }\n  ]\n  if (language == \"ruby\") return [\n    {when: (operations) => operations.has(\"probeEffect\"), text: \"class ProbeOperationFailure < StandardError; end\\n\"},\n    {when: (operations) => operations.has(\"probeAcquire\"), text: \"class ProbeAcquireFailure < StandardError; end\\n\"},\n    {when: (operations) => operations.has(\"probeRead\"), text: \"class ProbeReadFailure < StandardError; end\\n\"},\n    {when: (operations) => operations.has(\"probeClose\"), text: \"class ProbeCloseFailure < StandardError; end\\n\"},\n    {when: (operations) => operations.has(\"probeRead\") || operations.has(\"probeClose\"), text: \"class ProbeResourceClosed < StandardError; end\\n\"},\n    {\n      when: resource,\n      text: \"class ProbeResource\\n  attr_accessor :handle, :closed\\n  def initialize(handle); @handle = handle; @closed = false; end\\nend\\n\"\n    },\n    {when: any, text: \"$__semantifold_task034_trace = []\\n\"},\n    {\n      when: (operations) => operations.has(\"probeEffect\"),\n      text: \"def probeEffect(label, value, fail_value)\\n  $__semantifold_task034_trace << \\\"effect:#{label}\\\"\\n  raise ProbeOperationFailure, \\\"ProbeOperationFailure\\\" if fail_value\\n  value\\nend\\n\"\n    },\n    {\n      when: (operations) => operations.has(\"probeAcquire\"),\n      text: \"def probeAcquire(fail_value)\\n  $__semantifold_task034_trace << \\\"acquire\\\"\\n  raise ProbeAcquireFailure, \\\"ProbeAcquireFailure\\\" if fail_value\\n  begin; ProbeResource.new(File.open(ENV.fetch(\\\"SEMANTIFOLD_TASK034_PROBE_PATH\\\"), \\\"r\\\")); rescue ProbeAcquireFailure; raise; rescue StandardError; raise ProbeAcquireFailure, \\\"ProbeAcquireFailure\\\"; end\\nend\\n\"\n    },\n    {\n      when: (operations) => operations.has(\"probeRead\"),\n      text: \"def probeRead(resource, fail_value)\\n  raise ProbeResourceClosed, \\\"ProbeResourceClosed\\\" if resource.closed\\n  $__semantifold_task034_trace << \\\"read\\\"\\n  raise ProbeReadFailure, \\\"ProbeReadFailure\\\" if fail_value\\n  begin; value = resource.handle.gets; value.nil? ? nil : value.chomp; rescue ProbeReadFailure; raise; rescue StandardError; raise ProbeReadFailure, \\\"ProbeReadFailure\\\"; end\\nend\\n\"\n    },\n    {\n      when: (operations) => operations.has(\"probeClose\"),\n      text: \"def probeClose(resource, fail_value)\\n  raise ProbeResourceClosed, \\\"ProbeResourceClosed\\\" if resource.closed\\n  $__semantifold_task034_trace << \\\"close\\\"\\n  begin; resource.handle.close; rescue StandardError; resource.closed = true; raise ProbeCloseFailure, \\\"ProbeCloseFailure\\\"; end\\n  resource.closed = true\\n  raise ProbeCloseFailure, \\\"ProbeCloseFailure\\\" if fail_value\\n  nil\\nend\\n\"\n    },\n    {when: (operations) => operations.has(\"probeTrace\"), text: \"def probeTrace; $__semantifold_task034_trace.join(\\\",\\\"); end\\n\"}\n  ]\n  const fs = /** @type {SupportSegment} */ ({when: (operations) => operations.has(\"probeAcquire\"), text: 'const __semantifoldTask034Fs = process.getBuiltinModule(\"node:fs\")\\n'})\n  const trace = language == \"javascript\"\n    ? {when: any, text: \"const __semantifoldTask034Trace = []\\n\"}\n    : {when: any, text: \"const __semantifoldTask034Trace: string[] = []\\n\"}\n  const resourceClass = language == \"javascript\"\n    ? {when: resource, text: \"class ProbeResource { constructor(handle) { this.handle = handle; this.closed = false; this.position = 0 } }\\n\"}\n    : {when: resource, text: \"class ProbeResource { closed = false; position = 0; constructor(readonly handle: number) {} }\\n\"}\n\n  if (language == \"javascript\") return [\n    fs,\n    {when: (operations) => operations.has(\"probeEffect\"), text: \"class ProbeOperationFailure extends Error {}\\n\"},\n    {when: (operations) => operations.has(\"probeAcquire\"), text: \"class ProbeAcquireFailure extends Error {}\\n\"},\n    {when: (operations) => operations.has(\"probeRead\"), text: \"class ProbeReadFailure extends Error {}\\n\"},\n    {when: (operations) => operations.has(\"probeClose\"), text: \"class ProbeCloseFailure extends Error {}\\n\"},\n    {when: (operations) => operations.has(\"probeRead\") || operations.has(\"probeClose\"), text: \"class ProbeResourceClosed extends Error {}\\n\"},\n    resourceClass,\n    trace,\n    {\n      when: (operations) => operations.has(\"probeEffect\"),\n      text: 'function probeEffect(label, value, fail) { __semantifoldTask034Trace.push(`effect:${label}`); if (fail) throw new ProbeOperationFailure(\"ProbeOperationFailure\"); return value }\\n'\n    },\n    {\n      when: (operations) => operations.has(\"probeAcquire\"),\n      text: 'function probeAcquire(fail) { __semantifoldTask034Trace.push(\"acquire\"); if (fail) throw new ProbeAcquireFailure(\"ProbeAcquireFailure\"); try { return new ProbeResource(__semantifoldTask034Fs.openSync(process.env.SEMANTIFOLD_TASK034_PROBE_PATH, \"r\")) } catch { throw new ProbeAcquireFailure(\"ProbeAcquireFailure\") } }\\n'\n    },\n    {\n      when: (operations) => operations.has(\"probeRead\"),\n      text: 'function probeRead(resource, fail) { if (resource.closed) throw new ProbeResourceClosed(\"ProbeResourceClosed\"); __semantifoldTask034Trace.push(\"read\"); if (fail) throw new ProbeReadFailure(\"ProbeReadFailure\"); try { const bytes = []; const buffer = Buffer.alloc(1); while (true) { const count = __semantifoldTask034Fs.readSync(resource.handle, buffer, 0, 1, resource.position++); if (count === 0) return bytes.length === 0 ? null : Buffer.from(bytes).toString(\"utf8\"); if (buffer[0] === 10) return Buffer.from(bytes).toString(\"utf8\").replace(/\\\\r$/u, \"\"); bytes.push(buffer[0]) } } catch { throw new ProbeReadFailure(\"ProbeReadFailure\") } }\\n'\n    },\n    {\n      when: (operations) => operations.has(\"probeClose\"),\n      text: 'function probeClose(resource, fail) { if (resource.closed) throw new ProbeResourceClosed(\"ProbeResourceClosed\"); __semantifoldTask034Trace.push(\"close\"); try { __semantifoldTask034Fs.closeSync(resource.handle) } catch { resource.closed = true; throw new ProbeCloseFailure(\"ProbeCloseFailure\") } resource.closed = true; if (fail) throw new ProbeCloseFailure(\"ProbeCloseFailure\") }\\n'\n    },\n    {when: (operations) => operations.has(\"probeTrace\"), text: 'function probeTrace() { return __semantifoldTask034Trace.join(\",\") }\\n'}\n  ]\n  return [\n    fs,\n    {when: (operations) => operations.has(\"probeEffect\"), text: \"class ProbeOperationFailure extends Error {}\\n\"},\n    {when: (operations) => operations.has(\"probeAcquire\"), text: \"class ProbeAcquireFailure extends Error {}\\n\"},\n    {when: (operations) => operations.has(\"probeRead\"), text: \"class ProbeReadFailure extends Error {}\\n\"},\n    {when: (operations) => operations.has(\"probeClose\"), text: \"class ProbeCloseFailure extends Error {}\\n\"},\n    {when: (operations) => operations.has(\"probeRead\") || operations.has(\"probeClose\"), text: \"class ProbeResourceClosed extends Error {}\\n\"},\n    resourceClass,\n    trace,\n    {\n      when: (operations) => operations.has(\"probeEffect\"),\n      text: 'function probeEffect(label: string, value: number, fail: boolean): number { __semantifoldTask034Trace.push(`effect:${label}`); if (fail) throw new ProbeOperationFailure(\"ProbeOperationFailure\"); return value }\\n'\n    },\n    {\n      when: (operations) => operations.has(\"probeAcquire\"),\n      text: 'function probeAcquire(fail: boolean): ProbeResource { __semantifoldTask034Trace.push(\"acquire\"); if (fail) throw new ProbeAcquireFailure(\"ProbeAcquireFailure\"); try { return new ProbeResource(__semantifoldTask034Fs.openSync(process.env.SEMANTIFOLD_TASK034_PROBE_PATH as string, \"r\")) } catch { throw new ProbeAcquireFailure(\"ProbeAcquireFailure\") } }\\n'\n    },\n    {\n      when: (operations) => operations.has(\"probeRead\"),\n      text: 'function probeRead(resource: ProbeResource, fail: boolean): string | null { if (resource.closed) throw new ProbeResourceClosed(\"ProbeResourceClosed\"); __semantifoldTask034Trace.push(\"read\"); if (fail) throw new ProbeReadFailure(\"ProbeReadFailure\"); try { const bytes: number[] = []; const buffer = Buffer.alloc(1); while (true) { const count = __semantifoldTask034Fs.readSync(resource.handle, buffer, 0, 1, resource.position++); if (count === 0) return bytes.length === 0 ? null : Buffer.from(bytes).toString(\"utf8\"); if (buffer[0] === 10) return Buffer.from(bytes).toString(\"utf8\").replace(/\\\\r$/u, \"\"); bytes.push(buffer[0]) } } catch { throw new ProbeReadFailure(\"ProbeReadFailure\") } }\\n'\n    },\n    {\n      when: (operations) => operations.has(\"probeClose\"),\n      text: 'function probeClose(resource: ProbeResource, fail: boolean): void { if (resource.closed) throw new ProbeResourceClosed(\"ProbeResourceClosed\"); __semantifoldTask034Trace.push(\"close\"); try { __semantifoldTask034Fs.closeSync(resource.handle) } catch { resource.closed = true; throw new ProbeCloseFailure(\"ProbeCloseFailure\") } resource.closed = true; if (fail) throw new ProbeCloseFailure(\"ProbeCloseFailure\") }\\n'\n    },\n    {when: (operations) => operations.has(\"probeTrace\"), text: 'function probeTrace(): string { return __semantifoldTask034Trace.join(\",\") }\\n'}\n  ]\n}\n\n/**\n * Generates the complete tree-shaken stdlib provider artifact content for one adopted target.\n * @param {StdlibProviderTarget} language - Adopted target host provider.\n * @param {readonly string[]} operations - Used canonical operations in contract order.\n * @param {string} [module] - Qualified canonical module identity; omitted for the Task 034 probe.\n * @returns {string} Complete provider source text.\n */\nexport function generateStdlibProviderContent(language, operations, module) {\n  if (module !== undefined && module != \"semantifold.task034.resource-probe\") {\n    if (language != \"php\") throw new RangeError(`Canonical module '${module}' has no '${language}' provider content.`)\n    return generateTask037PhpProviderContent(module, operations)\n  }\n  const used = new Set(operations)\n\n  if (used.size == 0) throw new Error(\"A stdlib provider requires at least one used operation.\")\n  const segments = supportSegments(language)\n  const start = language == \"ruby\" ? \"# semantifold-task034-support\\n\" : \"/* semantifold-task034-support */\\n\"\n  const end = language == \"ruby\" ? \"# semantifold-task034-support-end\\n\\n\" : \"/* semantifold-task034-support-end */\\n\\n\"\n  const support = start +\n    segments.filter(({when}) => when(used)).map(({text}) => text).join(\"\") +\n    end\n  const header = language == \"php\" ? \"<?php\\ndeclare(strict_types=1);\\n\" : \"\"\n  const classExports = language == \"javascript\" || language == \"typescript\" ?\n    `export {${[\n      [\"ProbeOperationFailure\", used.has(\"probeEffect\")],\n      [\"ProbeAcquireFailure\", used.has(\"probeAcquire\")],\n      [\"ProbeReadFailure\", used.has(\"probeRead\")],\n      [\"ProbeCloseFailure\", used.has(\"probeClose\")],\n      [\"ProbeResourceClosed\", used.has(\"probeRead\") || used.has(\"probeClose\")],\n      [\"ProbeResource\", used.has(\"probeAcquire\") || used.has(\"probeRead\") || used.has(\"probeClose\")]\n    ].filter(([, present]) => present).map(([name]) => name).join(\", \")}}\\n` : \"\"\n  const shims = providerShims(language, operations)\n\n  return header + support + classExports + (shims.length > 0 ? shims.join(\"\\n\") + \"\\n\" : \"\")\n}\n"]}

package/build/src/backends/swift-runtime.d.ts

@@ -0,0 +1,3 @@
+/** Exact target-only support for Unicode-scalar string equality. */
+export declare const swiftRuntime = "func semantifold_string_equal(_ left: String, _ right: String) -> Bool {\n  return left.unicodeScalars.elementsEqual(right.unicodeScalars)\n}\n\nfunc semantifold_string_not_equal(_ left: String, _ right: String) -> Bool {\n  return !left.unicodeScalars.elementsEqual(right.unicodeScalars)\n}\n\nfunc semantifold_keep_mutable<T>(_ value: inout T) {\n}\n";
+//# sourceMappingURL=swift-runtime.d.ts.map

package/build/src/backends/swift-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift-runtime.d.ts","sourceRoot":"","sources":["../../../src/backends/swift-runtime.js"],"names":[],"mappings":"AAEA,oEAAoE;AACpE,eAAO,MAAM,YAAY,qWAUxB,CAAA"}

package/build/src/backends/swift-runtime.js

@@ -0,0 +1,14 @@
+// @ts-check
+/** Exact target-only support for Unicode-scalar string equality. */
+export const swiftRuntime = `func semantifold_string_equal(_ left: String, _ right: String) -> Bool {
+  return left.unicodeScalars.elementsEqual(right.unicodeScalars)
+}
+
+func semantifold_string_not_equal(_ left: String, _ right: String) -> Bool {
+  return !left.unicodeScalars.elementsEqual(right.unicodeScalars)
+}
+
+func semantifold_keep_mutable<T>(_ value: inout T) {
+}
+`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dpZnQtcnVudGltZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9iYWNrZW5kcy9zd2lmdC1ydW50aW1lLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixvRUFBb0U7QUFDcEUsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHOzs7Ozs7Ozs7O0NBVTNCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcblxuLyoqIEV4YWN0IHRhcmdldC1vbmx5IHN1cHBvcnQgZm9yIFVuaWNvZGUtc2NhbGFyIHN0cmluZyBlcXVhbGl0eS4gKi9cbmV4cG9ydCBjb25zdCBzd2lmdFJ1bnRpbWUgPSBgZnVuYyBzZW1hbnRpZm9sZF9zdHJpbmdfZXF1YWwoXyBsZWZ0OiBTdHJpbmcsIF8gcmlnaHQ6IFN0cmluZykgLT4gQm9vbCB7XG4gIHJldHVybiBsZWZ0LnVuaWNvZGVTY2FsYXJzLmVsZW1lbnRzRXF1YWwocmlnaHQudW5pY29kZVNjYWxhcnMpXG59XG5cbmZ1bmMgc2VtYW50aWZvbGRfc3RyaW5nX25vdF9lcXVhbChfIGxlZnQ6IFN0cmluZywgXyByaWdodDogU3RyaW5nKSAtPiBCb29sIHtcbiAgcmV0dXJuICFsZWZ0LnVuaWNvZGVTY2FsYXJzLmVsZW1lbnRzRXF1YWwocmlnaHQudW5pY29kZVNjYWxhcnMpXG59XG5cbmZ1bmMgc2VtYW50aWZvbGRfa2VlcF9tdXRhYmxlPFQ+KF8gdmFsdWU6IGlub3V0IFQpIHtcbn1cbmBcbiJdfQ==

package/build/src/backends/swift.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Emits one deterministic dependency-free Swift program through the source-aware writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated semantic module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+export declare function generateSwift(module: import("../semantic/types.js").SemanticModule, writer: import("./writer.js").SourceWriter): void;
+//# sourceMappingURL=swift.d.ts.map

package/build/src/backends/swift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift.d.ts","sourceRoot":"","sources":["../../../src/backends/swift.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAJzB,OAAO,sBAAsB,EAAE,cAIN,EAAE,MAAM,EAHjC,OAAO,aAAa,EAAE,YAGW,GAF/B,IAAI,CAiChB"}

package/build/src/backends/swift.js

@@ -0,0 +1,127 @@
+// @ts-check
+import { emitExpression } from "./shared.js";
+import { emitScalarType } from "./scalars.js";
+import { swiftRuntime } from "./swift-runtime.js";
+/**
+ * Emits one deterministic dependency-free Swift program through the source-aware writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated semantic module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+export function generateSwift(module, writer) {
+    writer.synthetic(swiftRuntime, "Exact Swift Unicode-scalar string equality support", [module], [""]);
+    module.functions.forEach((declaration, functionIndex) => {
+        const path = `/functions/${functionIndex}`;
+        writer.synthetic("\n", "declaration separator", [declaration], [path]);
+        writer.mapped("func", { mappingKind: "anchor", node: declaration, path });
+        writer.synthetic(" ", "declaration spacing", [declaration], [path]);
+        writer.mapped(declaration.name, { mappingKind: "exact", node: declaration, path, role: "name" });
+        writer.synthetic("(", "function parameter scaffold", [declaration], [path]);
+        declaration.parameters.forEach((parameter, parameterIndex) => {
+            const parameterPath = `${path}/parameters/${parameterIndex}`;
+            if (parameterIndex)
+                writer.synthetic(", ", "parameter separator", [parameter], [parameterPath]);
+            writer.synthetic("_ ", "unlabeled Swift parameter scaffold", [parameter], [parameterPath]);
+            writer.mapped(parameter.name, { mappingKind: "exact", node: parameter, path: parameterPath, role: "name" });
+            writer.synthetic(": ", "parameter annotation scaffold", [parameter], [parameterPath]);
+            writer.mapped(emitScalarType("swift", parameter.type), { mappingKind: "exact", node: parameter.type,
+                path: `${parameterPath}/type`, role: "type" });
+        });
+        writer.synthetic(") -> ", "function return scaffold", [declaration], [path]);
+        writer.mapped(emitScalarType("swift", declaration.returnType), { mappingKind: "exact", node: declaration.returnType,
+            path: `${path}/returnType`, role: "type" });
+        writer.synthetic(" {\n", "Swift function body scaffold", [declaration], [path]);
+        emitBlock(writer, declaration.body, "  ", `${path}/body`);
+        writer.synthetic("}\n", "Swift function body scaffold", [declaration], [path]);
+    });
+    writer.synthetic("\n", "Swift top-level entry scaffold", [module.entryPoint], ["/entryPoint"]);
+    emitBlock(writer, module.entryPoint.body, "", "/entryPoint/body");
+}
+/**
+ * Emits one ordered Swift block.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {string} indent - Current indentation.
+ * @param {string} path - Exact block path.
+ * @returns {void}
+ */
+function emitBlock(writer, block, indent, path) {
+    block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`));
+}
+/**
+ * Emits one validated Swift statement.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Statement} statement - Semantic statement.
+ * @param {string} indent - Current indentation.
+ * @param {string} path - Statement occurrence path.
+ * @returns {void}
+ */
+function emitStatement(writer, statement, indent, path) {
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    if (statement.kind == "LocalDeclaration") {
+        writer.mapped(statement.mutable ? "var" : "let", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic(" ", "declaration spacing", [statement], [path]);
+        writer.mapped(statement.name, { mappingKind: "exact", node: statement, path, role: "name" });
+        writer.synthetic(": ", "local annotation scaffold", [statement], [path]);
+        writer.mapped(emitScalarType("swift", statement.type), { mappingKind: "exact", node: statement.type,
+            path: `${path}/type`, role: "type" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        writer.mapped("=", { mappingKind: "exact", node: statement, path, role: "operator" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        emitExpression(writer, statement.initializer, `${path}/initializer`, "swift", identity);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        if (statement.mutable) {
+            writer.synthetic(`${indent}semantifold_keep_mutable(&${statement.name})\n`, "Swift mutable-local warning marker", [statement], [path]);
+        }
+        return;
+    }
+    if (statement.kind == "AssignmentStatement") {
+        writer.mapped(statement.target.name, { mappingKind: "exact", node: statement.target, path: `${path}/target`, role: "name" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        writer.mapped("=", { mappingKind: "exact", node: statement, path, role: "operator" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, "swift", identity);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    if (statement.kind == "ExpressionStatement")
+        throw new TypeError("Swift Task 005 expression statement reached emission.");
+    if (statement.kind == "ReturnStatement") {
+        if (!statement.expression)
+            throw new TypeError("Swift bare return reached emission.");
+        writer.mapped("return", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic(" ", "return spacing", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, "swift", identity);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    if (statement.kind == "PrintStatement") {
+        writer.synthetic("print(", "Swift print plumbing", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, "swift", identity);
+        writer.synthetic(")\n", "Swift print plumbing", [statement], [path]);
+        return;
+    }
+    if (statement.kind != "IfStatement")
+        throw new TypeError("Unsupported Swift statement reached emission.");
+    writer.mapped("if", { mappingKind: "anchor", node: statement, path });
+    writer.synthetic(" ", "conditional spacing", [statement], [path]);
+    emitExpression(writer, statement.condition, `${path}/condition`, "swift", identity);
+    writer.synthetic(" {\n", "Swift conditional scaffold", [statement.consequent], [`${path}/consequent`]);
+    emitBlock(writer, statement.consequent, `${indent}  `, `${path}/consequent`);
+    writer.synthetic(`${indent}}`, "Swift conditional scaffold", [statement.consequent], [`${path}/consequent`]);
+    if (statement.alternate) {
+        writer.synthetic(" else {\n", "Swift alternate scaffold", [statement.alternate], [`${path}/alternate`]);
+        emitBlock(writer, statement.alternate, `${indent}  `, `${path}/alternate`);
+        writer.synthetic(`${indent}}`, "Swift alternate scaffold", [statement.alternate], [`${path}/alternate`]);
+    }
+    writer.synthetic("\n", "line break", [statement], [path]);
+}
+/**
+ * Returns an unchanged Swift identifier.
+ * @param {string} name - Validated identifier.
+ * @returns {string} Unchanged identifier.
+ */
+function identity(name) {
+    return name;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"swift.js","sourceRoot":"","sources":["../../../src/backends/swift.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {emitExpression} from \"./shared.js\"\nimport {emitScalarType} from \"./scalars.js\"\nimport {swiftRuntime} from \"./swift-runtime.js\"\n\n/**\n * Emits one deterministic dependency-free Swift program through the source-aware writer.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated semantic module.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @returns {void}\n */\nexport function generateSwift(module, writer) {\n  writer.synthetic(swiftRuntime, \"Exact Swift Unicode-scalar string equality support\", [module], [\"\"])\n\n  module.functions.forEach((declaration, functionIndex) => {\n    const path = `/functions/${functionIndex}`\n\n    writer.synthetic(\"\\n\", \"declaration separator\", [declaration], [path])\n    writer.mapped(\"func\", {mappingKind: \"anchor\", node: declaration, path})\n    writer.synthetic(\" \", \"declaration spacing\", [declaration], [path])\n    writer.mapped(declaration.name, {mappingKind: \"exact\", node: declaration, path, role: \"name\"})\n    writer.synthetic(\"(\", \"function parameter scaffold\", [declaration], [path])\n    declaration.parameters.forEach((parameter, parameterIndex) => {\n      const parameterPath = `${path}/parameters/${parameterIndex}`\n\n      if (parameterIndex) writer.synthetic(\", \", \"parameter separator\", [parameter], [parameterPath])\n      writer.synthetic(\"_ \", \"unlabeled Swift parameter scaffold\", [parameter], [parameterPath])\n      writer.mapped(parameter.name, {mappingKind: \"exact\", node: parameter, path: parameterPath, role: \"name\"})\n      writer.synthetic(\": \", \"parameter annotation scaffold\", [parameter], [parameterPath])\n      writer.mapped(emitScalarType(\"swift\", parameter.type), {mappingKind: \"exact\", node: parameter.type,\n        path: `${parameterPath}/type`, role: \"type\"})\n    })\n    writer.synthetic(\") -> \", \"function return scaffold\", [declaration], [path])\n    writer.mapped(emitScalarType(\"swift\", declaration.returnType), {mappingKind: \"exact\", node: declaration.returnType,\n      path: `${path}/returnType`, role: \"type\"})\n    writer.synthetic(\" {\\n\", \"Swift function body scaffold\", [declaration], [path])\n    emitBlock(writer, declaration.body, \"  \", `${path}/body`)\n    writer.synthetic(\"}\\n\", \"Swift function body scaffold\", [declaration], [path])\n  })\n\n  writer.synthetic(\"\\n\", \"Swift top-level entry scaffold\", [module.entryPoint], [\"/entryPoint\"])\n  emitBlock(writer, module.entryPoint.body, \"\", \"/entryPoint/body\")\n}\n\n/**\n * Emits one ordered Swift block.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @param {string} indent - Current indentation.\n * @param {string} path - Exact block path.\n * @returns {void}\n */\nfunction emitBlock(writer, block, indent, path) {\n  block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`))\n}\n\n/**\n * Emits one validated Swift statement.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").Statement} statement - Semantic statement.\n * @param {string} indent - Current indentation.\n * @param {string} path - Statement occurrence path.\n * @returns {void}\n */\nfunction emitStatement(writer, statement, indent, path) {\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  if (statement.kind == \"LocalDeclaration\") {\n    writer.mapped(statement.mutable ? \"var\" : \"let\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\" \", \"declaration spacing\", [statement], [path])\n    writer.mapped(statement.name, {mappingKind: \"exact\", node: statement, path, role: \"name\"})\n    writer.synthetic(\": \", \"local annotation scaffold\", [statement], [path])\n    writer.mapped(emitScalarType(\"swift\", statement.type), {mappingKind: \"exact\", node: statement.type,\n      path: `${path}/type`, role: \"type\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    writer.mapped(\"=\", {mappingKind: \"exact\", node: statement, path, role: \"operator\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    emitExpression(writer, statement.initializer, `${path}/initializer`, \"swift\", identity)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    if (statement.mutable) {\n      writer.synthetic(`${indent}semantifold_keep_mutable(&${statement.name})\\n`, \"Swift mutable-local warning marker\", [statement], [path])\n    }\n    return\n  }\n  if (statement.kind == \"AssignmentStatement\") {\n    writer.mapped(statement.target.name, {mappingKind: \"exact\", node: statement.target, path: `${path}/target`, role: \"name\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    writer.mapped(\"=\", {mappingKind: \"exact\", node: statement, path, role: \"operator\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, \"swift\", identity)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n  if (statement.kind == \"ExpressionStatement\") throw new TypeError(\"Swift Task 005 expression statement reached emission.\")\n  if (statement.kind == \"ReturnStatement\") {\n    if (!statement.expression) throw new TypeError(\"Swift bare return reached emission.\")\n    writer.mapped(\"return\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\" \", \"return spacing\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, \"swift\", identity)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n  if (statement.kind == \"PrintStatement\") {\n    writer.synthetic(\"print(\", \"Swift print plumbing\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, \"swift\", identity)\n    writer.synthetic(\")\\n\", \"Swift print plumbing\", [statement], [path])\n    return\n  }\n  if (statement.kind != \"IfStatement\") throw new TypeError(\"Unsupported Swift statement reached emission.\")\n\n  writer.mapped(\"if\", {mappingKind: \"anchor\", node: statement, path})\n  writer.synthetic(\" \", \"conditional spacing\", [statement], [path])\n  emitExpression(writer, statement.condition, `${path}/condition`, \"swift\", identity)\n  writer.synthetic(\" {\\n\", \"Swift conditional scaffold\", [statement.consequent], [`${path}/consequent`])\n  emitBlock(writer, statement.consequent, `${indent}  `, `${path}/consequent`)\n  writer.synthetic(`${indent}}`, \"Swift conditional scaffold\", [statement.consequent], [`${path}/consequent`])\n  if (statement.alternate) {\n    writer.synthetic(\" else {\\n\", \"Swift alternate scaffold\", [statement.alternate], [`${path}/alternate`])\n    emitBlock(writer, statement.alternate, `${indent}  `, `${path}/alternate`)\n    writer.synthetic(`${indent}}`, \"Swift alternate scaffold\", [statement.alternate], [`${path}/alternate`])\n  }\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n}\n\n/**\n * Returns an unchanged Swift identifier.\n * @param {string} name - Validated identifier.\n * @returns {string} Unchanged identifier.\n */\nfunction identity(name) {\n  return name\n}\n"]}

package/build/src/backends/typescript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/backends/typescript.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAJ9B,OAAO,sBAAsB,EAAE,cAID,EAAE,MAAM,EAHtC,OAAO,aAAa,EAAE,YAGgB,GAFpC,IAAI,CA2ChB"}
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/backends/typescript.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAJ9B,OAAO,sBAAsB,EAAE,cAID,EAAE,MAAM,EAHtC,OAAO,aAAa,EAAE,YAGgB,GAFpC,IAAI,CAqFhB"}