@jigging/jig 0.1.0-alpha.10 → 0.1.0-alpha.12

package/libexec/evaluator/project-evaluator-sdk.bundle.js

@@ -1783,6 +1783,18 @@ function normalizeJig(input, canonical) {
 function defineBinding(input) {
   return normalizeBinding(input, false);
 }
+function flowRef(path) {
+  return record({
+    kind: "flow",
+    path: normalizeProjectPath(path, "Flow reference")
+  });
+}
+function bindingRef(id) {
+  return record({
+    kind: "binding",
+    id: validateLocalName(id, "Binding reference")
+  });
+}
 function normalizeBinding(input, canonical) {
   const captured = snapshotJsonObject(input, "Binding definition");
   assertClosedObject(captured, canonical ? ["kind", "package", "settings", "slots"] : ["package", "settings", "slots"], "Binding definition");
@@ -1794,7 +1806,12 @@ function normalizeBinding(input, canonical) {
   const packagePath = normalizeProjectPath(captured.package, "package");
   const settings = Object.hasOwn(captured, "settings") ? expectJsonObject(captured.settings, "settings") : emptyRecord();
   const slots = Object.hasOwn(captured, "slots") ? normalizeFlowSlots(captured.slots) : emptyRecord();
-  return record({ kind: "package", package: packagePath, settings, slots });
+  return record({
+    kind: "package",
+    package: packagePath,
+    settings,
+    slots
+  });
 }
 function normalizeFlowSlots(value) {
   const input = snapshotJsonObject(value, "slots");
@@ -1804,10 +1821,20 @@ function normalizeFlowSlots(value) {
   const output = Object.create(null);
   for (const name of Object.keys(input).sort(compareUtf8)) {
     validateLocalName(name, "slot name");
-    output[name] = normalizeProjectPath(input[name], `slot ${name}`);
+    const target = parseRunTargetSelector(input[name], `slot ${name}`);
+    output[name] = target.kind === "flow" ? `flow:${target.path}` : `binding:${target.id}`;
   }
   return Object.freeze(output);
 }
+function parseRunTargetSelector(value, label) {
+  if (typeof value !== "string")
+    throw new TypeError(`${label} must be a target selector`);
+  if (value.startsWith("flow:"))
+    return flowRef(normalizeProjectPath(value.slice(5), label));
+  if (value.startsWith("binding:"))
+    return bindingRef(validateLocalName(value.slice(8), label));
+  throw new TypeError(`${label} must select flow:<path> or binding:<id>`);
+}
 function normalizeSource(value, field, canonical) {
   if (value === undefined)
     throw new TypeError(`${field} cannot be undefined`);

package/libexec/evaluator/project-evaluator-worker.js

@@ -240,65 +240,67 @@ async function build(request) {
       target: "bun",
       write: false,
       sourcemap: "none",
-      plugins: [{
-        name: "jig-closed-author-module",
-        setup(builder) {
-          builder.onResolve({ filter: /^jig-author:bridge$/ }, (arguments_) => {
-            if (arguments_.kind !== "entry-point-build" || arguments_.importer !== "") {
+      plugins: [
+        {
+          name: "jig-closed-author-module",
+          setup(builder) {
+            builder.onResolve({ filter: /^jig-author:bridge$/ }, (arguments_) => {
+              if (arguments_.kind !== "entry-point-build" || arguments_.importer !== "") {
+                throw deniedImport(arguments_.path);
+              }
+              return { path: arguments_.path, namespace: "jig-author" };
+            });
+            builder.onResolve({ filter: /^jig-author:entry$/ }, (arguments_) => {
+              if (arguments_.kind !== "import-statement" || arguments_.importer !== "jig-author:bridge") {
+                throw deniedImport(arguments_.path);
+              }
+              return { path: request.entryProjectPath, namespace: "jig-project" };
+            });
+            builder.onResolve({ filter: /^jig-author:/ }, (arguments_) => {
               throw deniedImport(arguments_.path);
-            }
-            return { path: arguments_.path, namespace: "jig-author" };
-          });
-          builder.onResolve({ filter: /^jig-author:entry$/ }, (arguments_) => {
-            if (arguments_.kind !== "import-statement" || arguments_.importer !== "jig-author:bridge") {
+            });
+            builder.onLoad({ filter: /^jig-author:bridge$/, namespace: "jig-author" }, () => ({
+              loader: "ts",
+              contents: bridge
+            }));
+            builder.onResolve({ filter: /^@jigging\/jig$/ }, (arguments_) => {
+              if (arguments_.kind !== "import-statement" || !modules.has(arguments_.importer)) {
+                throw deniedImport(arguments_.path);
+              }
+              return { path: "sdk", namespace: "jig-sealed" };
+            });
+            builder.onLoad({ filter: /^sdk$/, namespace: "jig-sealed" }, () => ({
+              loader: "js",
+              contents: sdkSource
+            }));
+            builder.onResolve({ filter: /.*/, namespace: "jig-sealed" }, (arguments_) => {
               throw deniedImport(arguments_.path);
-            }
-            return { path: request.entryProjectPath, namespace: "jig-project" };
-          });
-          builder.onResolve({ filter: /^jig-author:/ }, (arguments_) => {
-            throw deniedImport(arguments_.path);
-          });
-          builder.onLoad({ filter: /^jig-author:bridge$/, namespace: "jig-author" }, () => ({
-            loader: "ts",
-            contents: bridge
-          }));
-          builder.onResolve({ filter: /^@jigging\/jig$/ }, (arguments_) => {
-            if (arguments_.kind !== "import-statement" || !modules.has(arguments_.importer)) {
+            });
+            builder.onResolve({ filter: /.*/ }, (arguments_) => {
+              if (arguments_.kind !== "import-statement") {
+                throw deniedImport(`${arguments_.path} (${arguments_.kind} from ${arguments_.importer})`);
+              }
+              if (!modules.has(arguments_.importer)) {
+                throw deniedImport(`${arguments_.path} (from ${arguments_.importer})`);
+              }
+              const target = edges.get(`${arguments_.importer}\x00${arguments_.path}`);
+              if (target === undefined || !modules.has(target)) {
+                throw deniedImport(`${arguments_.path} (from ${arguments_.importer})`);
+              }
+              return { path: target, namespace: "jig-project" };
+            });
+            builder.onLoad({ filter: /.*/, namespace: "jig-project" }, (arguments_) => {
+              const module = modules.get(arguments_.path);
+              if (module === undefined)
+                return;
+              return { loader: "ts", contents: module.source };
+            });
+            builder.onResolve({ filter: /.*/, namespace: "jig-author" }, (arguments_) => {
               throw deniedImport(arguments_.path);
-            }
-            return { path: "sdk", namespace: "jig-sealed" };
-          });
-          builder.onLoad({ filter: /^sdk$/, namespace: "jig-sealed" }, () => ({
-            loader: "js",
-            contents: sdkSource
-          }));
-          builder.onResolve({ filter: /.*/, namespace: "jig-sealed" }, (arguments_) => {
-            throw deniedImport(arguments_.path);
-          });
-          builder.onResolve({ filter: /.*/ }, (arguments_) => {
-            if (arguments_.kind !== "import-statement") {
-              throw deniedImport(`${arguments_.path} (${arguments_.kind} from ${arguments_.importer})`);
-            }
-            if (!modules.has(arguments_.importer)) {
-              throw deniedImport(`${arguments_.path} (from ${arguments_.importer})`);
-            }
-            const target = edges.get(`${arguments_.importer}\x00${arguments_.path}`);
-            if (target === undefined || !modules.has(target)) {
-              throw deniedImport(`${arguments_.path} (from ${arguments_.importer})`);
-            }
-            return { path: target, namespace: "jig-project" };
-          });
-          builder.onLoad({ filter: /.*/, namespace: "jig-project" }, (arguments_) => {
-            const module = modules.get(arguments_.path);
-            if (module === undefined)
-              return;
-            return { loader: "ts", contents: module.source };
-          });
-          builder.onResolve({ filter: /.*/, namespace: "jig-author" }, (arguments_) => {
-            throw deniedImport(arguments_.path);
-          });
+            });
+          }
         }
-      }]
+      ]
     });
   } catch (error) {
     const message = boundedMessage(error);
@@ -417,7 +419,10 @@ function boundedMessage(error) {
   let message;
   try {
     if (error instanceof AggregateError) {
-      message = [error.message, ...error.errors.map((item) => item instanceof Error ? item.message : String(item))].join(": ");
+      message = [
+        error.message,
+        ...error.errors.map((item) => item instanceof Error ? item.message : String(item))
+      ].join(": ");
     } else {
       message = error instanceof Error ? error.message : String(error);
     }