feat(ruby): Implement RubyManifestParser for parsing gem groups and dependencies

feat(ruby): Add RubyVendorArtifactCollector to collect vendor artifacts

test(deno): Add golden tests for Deno analyzer with various fixtures

test(deno): Create Deno module and package files for testing

test(deno): Implement Deno lock and import map for dependency management

test(deno): Add FFI and worker scripts for Deno testing

feat(ruby): Set up Ruby workspace with Gemfile and dependencies

feat(ruby): Add expected output for Ruby workspace tests

feat(signals): Introduce CallgraphManifest model for signal processing

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Deno.Tests/Bundles/BundleInspectorTests.cs

@@ -62,8 +62,8 @@ public sealed class BundleInspectorTests
             var scan = DenoBundleScanner.Scan(temp, CancellationToken.None);
             var observations = DenoBundleScanner.ToObservations(scan);
 
-            Assert.Equal(1, scan.EszipBundles.Length);
-            Assert.Equal(1, scan.CompiledBundles.Length);
+            Assert.Single(scan.EszipBundles);
+            Assert.Single(scan.CompiledBundles);
             Assert.Equal(2, observations.Length);
             Assert.Contains(observations, obs => obs.BundleType == "eszip");
             Assert.Contains(observations, obs => obs.BundleType == "deno-compile");

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Deno.Tests/Containers/ContainerAdapterTests.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using StellaOps.Scanner.Analyzers.Lang.Deno.Internal;
 using StellaOps.Scanner.Analyzers.Lang.Deno.Tests.TestFixtures;
 using StellaOps.Scanner.Analyzers.Lang.Tests.TestUtilities;
@@ -21,9 +22,24 @@ public sealed class ContainerAdapterTests
             var inputs = DenoContainerAdapter.CollectInputs(workspace, observations);
 
             Assert.NotEmpty(inputs);
-            Assert.Contains(inputs, input => input.Kind == DenoContainerSourceKind.Cache);
-            Assert.Contains(inputs, input => input.Kind == DenoContainerSourceKind.Vendor);
-            Assert.Contains(inputs, input => input.Kind == DenoContainerSourceKind.Bundle);
+
+            var cacheInputs = inputs.Where(input => input.Kind == DenoContainerSourceKind.Cache).ToArray();
+            Assert.Equal(3, cacheInputs.Length);
+            Assert.All(cacheInputs, cache => Assert.True(cache.Metadata.ContainsKey("path")));
+
+            var vendorInputs = inputs.Where(input => input.Kind == DenoContainerSourceKind.Vendor).ToArray();
+            Assert.Equal(2, vendorInputs.Length);
+            Assert.Contains(vendorInputs, vendor => vendor.Metadata.TryGetValue("alias", out var alias) && alias?.Contains("vendor", StringComparison.OrdinalIgnoreCase) == true);
+
+            var bundleInputs = inputs.Where(input => input.Kind == DenoContainerSourceKind.Bundle).ToArray();
+            Assert.Equal(2, bundleInputs.Length);
+            Assert.Contains(bundleInputs, bundle => string.Equals(bundle.Bundle?.BundleType, "eszip", StringComparison.OrdinalIgnoreCase));
+            Assert.Contains(bundleInputs, bundle => string.Equals(bundle.Bundle?.BundleType, "deno-compile", StringComparison.OrdinalIgnoreCase));
+            Assert.All(bundleInputs, bundle =>
+            {
+                Assert.True(bundle.Metadata.ContainsKey("entrypoint"));
+                Assert.True(bundle.Metadata.ContainsKey("moduleCount"));
+            });
         }
         finally
         {

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Deno.Tests/Deno/DenoWorkspaceNormalizerTests.cs

@@ -70,6 +70,7 @@ public sealed class DenoWorkspaceNormalizerTests
 
             var graph = DenoModuleGraphResolver.Resolve(workspace, CancellationToken.None);
             var compatibility = DenoNpmCompatibilityAdapter.Analyze(workspace, graph, CancellationToken.None);
+            var cacheSummary = string.Join(";", workspace.CacheLocations.Select(cache => $"{cache.Kind}:{cache.AbsolutePath}"));
 
             Assert.NotEmpty(graph.Nodes);
             Assert.NotEmpty(graph.Edges);
@@ -108,7 +109,7 @@ public sealed class DenoWorkspaceNormalizerTests
                 usage => usage.Specifier == "node:fs");
 
             var npmResolution = compatibility.NpmResolutions.First(res => res.Specifier == "npm:dayjs@1");
-            Assert.True(npmResolution.ExistsOnDisk);
+            Assert.True(npmResolution.ExistsOnDisk, $"ResolvedPath={npmResolution.ResolvedPath ?? "(null)"}");
             Assert.Equal("deno", npmResolution.Condition);
             Assert.True(npmResolution.ResolvedPath?.EndsWith("deno.mod.ts", StringComparison.OrdinalIgnoreCase));
         }

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Deno.Tests/Golden/DenoAnalyzerGoldenTests.cs

@@ -0,0 +1,47 @@
+using StellaOps.Scanner.Analyzers.Lang;
+using StellaOps.Scanner.Analyzers.Lang.Deno;
+using StellaOps.Scanner.Analyzers.Lang.Tests.Harness;
+using StellaOps.Scanner.Analyzers.Lang.Tests.TestUtilities;
+
+namespace StellaOps.Scanner.Analyzers.Lang.Deno.Tests.Golden;
+
+public sealed class DenoAnalyzerGoldenTests
+{
+    [Fact]
+    public async Task AnalyzerMatchesGoldenSnapshotAsync()
+    {
+        var fixture = TestPaths.ResolveFixture("lang", "deno", "full");
+        var golden = Path.Combine(fixture, "expected.json");
+        var analyzers = new ILanguageAnalyzer[] { new DenoLanguageAnalyzer() };
+        var cancellationToken = TestContext.Current.CancellationToken;
+
+        var json = await LanguageAnalyzerTestHarness.RunToJsonAsync(fixture, analyzers, cancellationToken).ConfigureAwait(false);
+        var normalized = Normalize(json, fixture);
+        var expected = await File.ReadAllTextAsync(golden, cancellationToken).ConfigureAwait(false);
+
+        normalized = normalized.TrimEnd();
+        expected = expected.TrimEnd();
+
+        if (!string.Equals(expected, normalized, StringComparison.Ordinal))
+        {
+            var actualPath = golden + ".actual";
+            await File.WriteAllTextAsync(actualPath, normalized, cancellationToken).ConfigureAwait(false);
+        }
+
+        Assert.Equal(expected, normalized);
+    }
+
+    private static string Normalize(string json, string workspaceRoot)
+    {
+        if (string.IsNullOrWhiteSpace(json))
+        {
+            return string.Empty;
+        }
+
+        var normalizedRoot = workspaceRoot.Replace("\\", "/", StringComparison.Ordinal);
+        var builder = json.Replace(normalizedRoot, "<workspace>", StringComparison.Ordinal);
+        var altRoot = workspaceRoot.Replace("/", "\\", StringComparison.Ordinal);
+        builder = builder.Replace(altRoot, "<workspace>", StringComparison.Ordinal);
+        return builder;
+    }
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Deno.Tests/Observations/DenoLanguageAnalyzerObservationTests.cs

@@ -1,3 +1,5 @@
+using System.Linq;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using StellaOps.Scanner.Analyzers.Lang;
@@ -37,6 +39,27 @@ public sealed class DenoLanguageAnalyzerObservationTests
             Assert.True(payload.Content.Length > 0);
             Assert.NotNull(payload.Metadata);
             Assert.True(payload.Metadata!.ContainsKey("deno.observation.hash"));
+
+            using var document = JsonDocument.Parse(payload.Content.Span);
+            var root = document.RootElement;
+
+            var entrypoints = root.GetProperty("entrypoints").EnumerateArray().Select(element => element.GetString()).ToArray();
+            Assert.Contains("src/main.ts", entrypoints);
+
+            var capabilities = root.GetProperty("capabilities").EnumerateArray().ToArray();
+            Assert.Contains(capabilities, capability => capability.GetProperty("reason").GetString() == "builtin.deno.ffi");
+            Assert.Contains(capabilities, capability => capability.GetProperty("reason").GetString() == "builtin.node.worker_threads");
+            Assert.Contains(capabilities, capability => capability.GetProperty("reason").GetString() == "builtin.node.fs");
+
+            var dynamicImports = root.GetProperty("dynamicImports").EnumerateArray().Select(element => element.GetProperty("specifier").GetString()).ToArray();
+            Assert.Contains("https://cdn.example.com/dynamic/mod.ts", dynamicImports);
+
+            var literalFetches = root.GetProperty("literalFetches").EnumerateArray().Select(element => element.GetProperty("url").GetString()).ToArray();
+            Assert.Contains("https://api.example.com/data.json", literalFetches);
+
+            var bundles = root.GetProperty("bundles").EnumerateArray().ToArray();
+            Assert.Contains(bundles, bundle => bundle.GetProperty("type").GetString() == "eszip");
+            Assert.Contains(bundles, bundle => bundle.GetProperty("type").GetString() == "deno-compile");
         }
         finally
         {

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Deno.Tests/TestFixtures/BundleFixtureBuilder.cs

@@ -1,6 +1,8 @@
 using System.IO.Compression;
+using System.Text;
+using StellaOps.Scanner.Analyzers.Lang.Deno.Internal;
 
-namespace StellaOps.Scanner.Analyzers.Lang.Deno.Tests.TestFixtures;
+namespace StellaOps.Scanner.Analyzers.Lang.Deno.Fixtures;
 
 internal static class BundleFixtureBuilder
 {
@@ -8,6 +10,10 @@ internal static class BundleFixtureBuilder
     {
         Directory.CreateDirectory(directory);
         var bundlePath = Path.Combine(directory, "sample.eszip");
+        if (File.Exists(bundlePath))
+        {
+            File.Delete(bundlePath);
+        }
 
         using (var archive = ZipFile.Open(bundlePath, ZipArchiveMode.Create))
         {
@@ -52,6 +58,10 @@ internal static class BundleFixtureBuilder
     {
         Directory.CreateDirectory(directory);
         var binaryPath = Path.Combine(directory, "sample.deno");
+        if (File.Exists(binaryPath))
+        {
+            File.Delete(binaryPath);
+        }
         var eszipPath = CreateSampleEszip(directory);
         var eszipBytes = File.ReadAllBytes(eszipPath);
 

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Deno.Tests/TestFixtures/DenoWorkspaceTestFixture.cs

@@ -1,3 +1,4 @@
+using StellaOps.Scanner.Analyzers.Lang.Deno.Fixtures;
 using StellaOps.Scanner.Analyzers.Lang.Tests.TestUtilities;
 
 namespace StellaOps.Scanner.Analyzers.Lang.Deno.Tests.TestFixtures;
@@ -19,106 +20,7 @@ internal static class DenoWorkspaceTestFixture
     private static void CreateDenoFixture(string root, out string envDenoDir)
     {
         Directory.CreateDirectory(root);
-
-        File.WriteAllText(Path.Combine(root, "deno.jsonc"), """
-        // sample deno config
-        {
-          "importMap": "./import_map.json",
-          "lock": {
-            "enabled": true,
-            "path": "./deno.lock"
-          },
-          "vendor": {
-            "enabled": true,
-            "path": "./vendor"
-          },
-          "nodeModulesDir": false,
-          "imports": {
-            "$std/": "https://deno.land/std@0.207.0/",
-            "app/": "./src/app/",
-            "data": "./data/data.json",
-            "npmDynamic": "npm:dayjs@1",
-            "nodeFs": "node:fs"
-          },
-          "scopes": {
-            "https://deno.land/": {
-              "fmt/": "https://deno.land/std@0.207.0/fmt/"
-            }
-          }
-        }
-        """);
-
-        Directory.CreateDirectory(Path.Combine(root, "src", "app"));
-        Directory.CreateDirectory(Path.Combine(root, "data"));
-        File.WriteAllText(Path.Combine(root, "data", "data.json"), "{ \"ok\": true }");
-        File.WriteAllText(
-            Path.Combine(root, "import_map.json"),
-            """
-            {
-              "imports": {
-                "app/": "./src/app/main.ts",
-                "vendor/": "https://deno.land/std@0.207.0/"
-              }
-            }
-            """);
-
-        File.WriteAllText(
-            Path.Combine(root, "deno.lock"),
-            """
-            {
-              "version": "4",
-              "remote": {
-                "https://deno.land/std@0.207.0/http/server.ts": "sha256-deadbeef",
-                "https://example.com/mod.ts": "sha256-feedface",
-                "node:fs": "builtin"
-              },
-              "redirects": {
-                "https://deno.land/std/http/server.ts": "https://deno.land/std@0.207.0/http/server.ts"
-              },
-              "npm": {
-                "specifiers": {
-                  "npm:dayjs@1": "dayjs@1.11.12"
-                },
-                "packages": {
-                  "dayjs@1.11.12": {
-                    "integrity": "sha512-sample",
-                    "dependencies": {
-                      "tslib": "tslib@2.6.3"
-                    }
-                  },
-                  "tslib@2.6.3": {
-                    "integrity": "sha512-tslib",
-                    "dependencies": {}
-                  }
-                }
-              }
-            }
-            """);
-
-        var vendorRoot = Path.Combine(root, "vendor", "https", "deno.land", "std@0.207.0", "http");
-        Directory.CreateDirectory(vendorRoot);
-        File.WriteAllText(Path.Combine(vendorRoot, "server.ts"), "export const vendor = true;");
-
-        var vendorBase = Path.Combine(root, "vendor");
-        File.WriteAllText(
-            Path.Combine(vendorBase, "import_map.json"),
-            """
-            {
-              "imports": {
-                "std/http/server.ts": "https://deno.land/std@0.207.0/http/server.ts"
-              }
-            }
-            """);
-        File.WriteAllText(
-            Path.Combine(vendorBase, "deno.lock"),
-            """
-            {
-              "version": "1",
-              "remote": {}
-            }
-            """);
-
-        CreateDenoDir(Path.Combine(root, ".deno"), "workspace.ts", includeRegistry: true);
+        CopyTemplateWorkspace(root);
 
         envDenoDir = Path.Combine(root, "env-deno");
         CreateDenoDir(envDenoDir, "env.ts");
@@ -130,6 +32,39 @@ internal static class DenoWorkspaceTestFixture
         var layerVendor = Path.Combine(layerFs, "vendor", "https", "layer.example");
         Directory.CreateDirectory(layerVendor);
         File.WriteAllText(Path.Combine(layerFs, "vendor", "import_map.json"), "{\"imports\":{\"layer/\": \"https://layer.example/\"}}");
+
+        var bundlesRoot = Path.Combine(root, "bundles");
+        Directory.CreateDirectory(bundlesRoot);
+        BundleFixtureBuilder.CreateSampleEszip(bundlesRoot);
+        BundleFixtureBuilder.CreateSampleCompiledBinary(bundlesRoot);
+    }
+
+    private static void CopyTemplateWorkspace(string destination)
+    {
+        var template = TestPaths.ResolveFixture("lang", "deno", "full");
+        CopyDirectory(template, destination);
+    }
+
+    private static void CopyDirectory(string source, string destination)
+    {
+        foreach (var directory in Directory.EnumerateDirectories(source, "*", SearchOption.AllDirectories))
+        {
+            var relative = Path.GetRelativePath(source, directory);
+            Directory.CreateDirectory(Path.Combine(destination, relative));
+        }
+
+        foreach (var file in Directory.EnumerateFiles(source, "*", SearchOption.AllDirectories))
+        {
+            if (file.EndsWith(".actual", StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            var relative = Path.GetRelativePath(source, file);
+            var target = Path.Combine(destination, relative);
+            Directory.CreateDirectory(Path.GetDirectoryName(target)!);
+            File.Copy(file, target, overwrite: true);
+        }
     }
 
     private static void CreateDenoDir(string root, string fileName, bool includeRegistry = false)
@@ -142,7 +77,7 @@ internal static class DenoWorkspaceTestFixture
         Directory.CreateDirectory(npm);
 
         File.WriteAllText(Path.Combine(deps, fileName), "export const cache = true;");
-        File.WriteAllText(Path.Combine(gen, $"{Path.GetFileNameWithoutExtension(fileName)}.js"), "console.log('gen');");
+        File.WriteAllText(Path.Combine(gen, $"{Path.GetFileNameWithoutExtension(fileName)}.js"), "console.log(gen);");
         File.WriteAllText(Path.Combine(npm, "package.json"), "{}");
 
         if (includeRegistry)

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/.deno/deps/https/cdn.example.com/dynamic/mod.ts

@@ -0,0 +1 @@
+export const dynamicValue = 42;

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/.deno/npm/registry.npmjs.org/dayjs/1.11.12/deno.mod.ts

@@ -0,0 +1 @@
+export const dayjs = () => ({ iso: () => "2024-09-01" });

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/.deno/npm/registry.npmjs.org/dayjs/1.11.12/esm/index.js

@@ -0,0 +1,3 @@
+export function dayjs() {
+  return { iso: () => "2024-09-01" };
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/.deno/npm/registry.npmjs.org/dayjs/1.11.12/lib/index.js

@@ -0,0 +1,3 @@
+module.exports = function dayjs() {
+  return { iso: () => "2024-09-01" };
+};

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/.deno/npm/registry.npmjs.org/dayjs/1.11.12/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "dayjs",
+  "version": "1.11.12",
+  "exports": {
+    ".": {
+      "deno": "./deno.mod.ts",
+      "import": "./esm/index.js",
+      "default": "./lib/index.js"
+    }
+  }
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/.deno/npm/registry.npmjs.org/tslib/2.6.3/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "tslib",
+  "version": "2.6.3"
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/data/data.json

@@ -0,0 +1,3 @@
+{
+  "ok": true
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/deno.jsonc

@@ -0,0 +1,24 @@
+// Deterministic Deno workspace exercising vendor, npm, FFI, worker, and fetch flows.
+{
+  "importMap": "./import_map.json",
+  "lock": {
+    "enabled": true,
+    "path": "./deno.lock"
+  },
+  "nodeModulesDir": false,
+  "tasks": {
+    "serve": "deno run --allow-net ./src/main.ts"
+  },
+  "compilerOptions": {
+    "strict": true,
+    "noUncheckedIndexedAccess": true
+  },
+  "vendor": {
+    "enabled": true,
+    "path": "./vendor"
+  },
+  "fmt": {
+    "useTabs": false,
+    "lineWidth": 100
+  }
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/deno.lock

@@ -0,0 +1,28 @@
+{
+  "version": "4",
+  "remote": {
+    "https://deno.land/std@0.207.0/http/server.ts": "sha256-deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+    "https://cdn.example.com/dynamic/mod.ts": "sha256-feedfacefeedfacefeedfacefeedfacefeedfacefeedfacefeedfacefeedface",
+    "https://api.example.com/data.json": "sha256-0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"
+  },
+  "redirects": {
+    "https://deno.land/std/http/server.ts": "https://deno.land/std@0.207.0/http/server.ts"
+  },
+  "npm": {
+    "specifiers": {
+      "npm:dayjs@1": "dayjs@1.11.12"
+    },
+    "packages": {
+      "dayjs@1.11.12": {
+        "integrity": "sha512-sample-dayjs-integrity",
+        "dependencies": {
+          "tslib": "tslib@2.6.3"
+        }
+      },
+      "tslib@2.6.3": {
+        "integrity": "sha512-sample-tslib",
+        "dependencies": {}
+      }
+    }
+  }
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/expected.json

@@ -0,0 +1 @@
+"pending"

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/import_map.json

@@ -0,0 +1,12 @@
+{
+  "imports": {
+    "app/": "./src/",
+    "ffi/": "./src/ffi/",
+    "workers/": "./src/workers/",
+    "npmDynamic": "npm:dayjs@1",
+    "nodeFs": "node:fs",
+    "nodeCrypto": "node:crypto",
+    "nodeWorker": "node:worker_threads",
+    "denoFfi": "deno:ffi"
+  }
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/src/ffi/bridge.ts

@@ -0,0 +1,6 @@
+export function openBridge() {
+  const lib = Deno.dlopen("./ffi/libexample.so", {
+    add: { parameters: ["i32", "i32"], result: "i32" }
+  });
+  lib.close();
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/src/ffi/libexample.so

@@ -0,0 +1 @@
+FAKEELF

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/src/main.ts

@@ -0,0 +1,41 @@
+import dayjs from "npmDynamic";
+import { serve } from "https://deno.land/std@0.207.0/http/server.ts";
+import { Worker } from "nodeWorker";
+import { dlopen } from "denoFfi";
+import "workers/metrics.ts";
+
+const dynamicTarget = "https://cdn.example.com/dynamic/mod.ts";
+const fetchTarget = "https://api.example.com/data.json";
+
+async function spinWorkers() {
+  const worker = new Worker(new URL("./workers/child.ts", import.meta.url), { type: "module" });
+  worker.postMessage({ kind: "child", payload: "ping" });
+
+  const shared = new SharedWorker(new URL("./workers/shared.ts", import.meta.url), { type: "module" });
+  shared.port.postMessage({ kind: "shared", payload: "metrics" });
+}
+
+function loadFfi() {
+  const lib = dlopen("./ffi/libexample.so", {
+    add: { parameters: ["i32", "i32"], result: "i32" }
+  });
+  try {
+    return lib.symbols;
+  } finally {
+    lib.close();
+  }
+}
+
+export async function main() {
+  await spinWorkers();
+  loadFfi();
+
+  await import(dynamicTarget);
+  await fetch(fetchTarget);
+
+  await serve(() => new Response(dayjs().format()), { hostname: "127.0.0.1", port: 8088 });
+}
+
+if (import.meta.main) {
+  await main();
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/src/workers/child.ts

@@ -0,0 +1,4 @@
+self.onmessage = (event) => {
+  const payload = event.data ?? {};
+  self.postMessage({ ...payload, worker: "child" });
+};

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/src/workers/metrics.ts

@@ -0,0 +1,3 @@
+addEventListener("message", (event) => {
+  console.log("metric", event.data);
+});

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/src/workers/shared.ts

@@ -0,0 +1,6 @@
+onconnect = (event) => {
+  const [port] = event.ports;
+  port.onmessage = (message) => {
+    port.postMessage({ kind: "shared", payload: message.data });
+  };
+};

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/deno/full/vendor/https/deno.land/std@0.207.0/http/server.ts

@@ -0,0 +1,3 @@
+export async function serve(handler: () => Response, _options?: { hostname?: string; port?: number }) {
+  return handler();
+}

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/ruby/workspace/.bundle/config

@@ -0,0 +1,3 @@
+---
+BUNDLE_GEMFILE: "apps/api/Gemfile"
+BUNDLE_PATH: "apps/api/vendor/bundle"

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/ruby/workspace/Gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 7.1.0"
+
+group :development, :test do
+  gem "pry"
+  gem "rubocop", require: false
+end
+
+group :production, :console do
+  gem "puma", "~> 6.4"
+end

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/ruby/workspace/Gemfile.lock

@@ -0,0 +1,19 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    pry (1.0.0)
+    puma (6.4.2)
+    rails (7.1.3)
+    rubocop (1.60.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry
+  puma (~> 6.4)
+  rails (~> 7.1.0)
+  rubocop
+
+BUNDLED WITH
+   2.5.10

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/ruby/workspace/app/main.rb

@@ -0,0 +1,6 @@
+require "rails"
+require "puma"
+require "bootsnap"
+require "sidekiq"
+
+puts "workspace"

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/ruby/workspace/apps/api/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+group :jobs do
+  gem "sidekiq"
+end
+
+gem "bootsnap"

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/ruby/workspace/apps/api/Gemfile.lock

@@ -0,0 +1,15 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bootsnap (1.18.4)
+    sidekiq (7.2.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bootsnap
+  sidekiq
+
+BUNDLED WITH
+   2.5.10

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Fixtures/lang/ruby/workspace/expected.json

@@ -0,0 +1 @@
+[]

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Lang/Ruby/RubyLanguageAnalyzerTests.cs

@@ -21,4 +21,17 @@ public sealed class RubyLanguageAnalyzerTests
             cancellationToken: TestContext.Current.CancellationToken,
             usageHints: usageHints);
     }
+
+    [Fact]
+    public async Task WorkspaceLockfilesAndVendorArtifactsAsync()
+    {
+        var fixture = TestPaths.ResolveFixture("lang", "ruby", "workspace");
+        var golden = Path.Combine(fixture, "expected.json");
+
+        await LanguageAnalyzerTestHarness.AssertDeterministicAsync(
+            fixture,
+            golden,
+            new ILanguageAnalyzer[] { new RubyLanguageAnalyzer() },
+            cancellationToken: TestContext.Current.CancellationToken);
+    }
 }

src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/TestUtilities/JavaClassFileFactory.cs

@@ -48,7 +48,7 @@ public static class JavaClassFileFactory
         using var buffer = new MemoryStream();
         using var writer = new BigEndianWriter(buffer);
 
-        WriteClassFileHeader(writer, constantPoolCount: 18);
+        WriteClassFileHeader(writer, constantPoolCount: 20);
 
         writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8(internalClassName); // #1
         writer.WriteByte((byte)ConstantTag.Class); writer.WriteUInt16(1); // #2
@@ -59,14 +59,16 @@ public static class JavaClassFileFactory
         writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("Code"); // #7
         writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8(resourcePath); // #8
         writer.WriteByte((byte)ConstantTag.String); writer.WriteUInt16(8); // #9
-        writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("java/lang/Class"); // #10
+        writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("java/lang/ClassLoader"); // #10
         writer.WriteByte((byte)ConstantTag.Class); writer.WriteUInt16(10); // #11
-        writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("getResource"); // #12
-        writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("(Ljava/lang/String;)Ljava/net/URL;"); // #13
+        writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("getSystemClassLoader"); // #12
+        writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("()Ljava/lang/ClassLoader;"); // #13
         writer.WriteByte((byte)ConstantTag.NameAndType); writer.WriteUInt16(12); writer.WriteUInt16(13); // #14
         writer.WriteByte((byte)ConstantTag.Methodref); writer.WriteUInt16(11); writer.WriteUInt16(14); // #15
-        writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("dummy"); // #16
-        writer.WriteByte((byte)ConstantTag.String); writer.WriteUInt16(16); // #17
+        writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("getResource"); // #16
+        writer.WriteByte((byte)ConstantTag.Utf8); writer.WriteUtf8("(Ljava/lang/String;)Ljava/net/URL;"); // #17
+        writer.WriteByte((byte)ConstantTag.NameAndType); writer.WriteUInt16(16); writer.WriteUInt16(17); // #18
+        writer.WriteByte((byte)ConstantTag.Methodref); writer.WriteUInt16(11); writer.WriteUInt16(18); // #19
 
         writer.WriteUInt16(0x0001); // public
         writer.WriteUInt16(2); // this class
@@ -76,7 +78,7 @@ public static class JavaClassFileFactory
         writer.WriteUInt16(0); // fields
         writer.WriteUInt16(1); // methods
 
-        WriteResourceLookupMethod(writer, methodNameIndex: 5, descriptorIndex: 6, classConstantIndex: 4, stringIndex: 9, methodRefIndex: 15);
+        WriteResourceLookupMethod(writer, methodNameIndex: 5, descriptorIndex: 6, systemLoaderMethodRefIndex: 15, stringIndex: 9, getResourceMethodRefIndex: 19);
 
         writer.WriteUInt16(0); // class attributes
 
@@ -188,7 +190,13 @@ public static class JavaClassFileFactory
         writer.WriteBytes(codeBytes);
     }
 
-    private static void WriteResourceLookupMethod(BigEndianWriter writer, ushort methodNameIndex, ushort descriptorIndex, ushort classConstantIndex, ushort stringIndex, ushort methodRefIndex)
+    private static void WriteResourceLookupMethod(
+        BigEndianWriter writer,
+        ushort methodNameIndex,
+        ushort descriptorIndex,
+        ushort systemLoaderMethodRefIndex,
+        ushort stringIndex,
+        ushort getResourceMethodRefIndex)
     {
         writer.WriteUInt16(0x0009);
         writer.WriteUInt16(methodNameIndex);
@@ -201,13 +209,13 @@ public static class JavaClassFileFactory
         {
             codeWriter.WriteUInt16(2);
             codeWriter.WriteUInt16(0);
-            codeWriter.WriteUInt32(8);
-            codeWriter.WriteByte(0x13); // ldc_w for class literal
-            codeWriter.WriteUInt16(classConstantIndex);
-            codeWriter.WriteByte(0x12);
+            codeWriter.WriteUInt32(10);
+            codeWriter.WriteByte(0xB8); // invokestatic
+            codeWriter.WriteUInt16(systemLoaderMethodRefIndex);
+            codeWriter.WriteByte(0x12); // ldc
             codeWriter.WriteByte((byte)stringIndex);
-            codeWriter.WriteByte(0xB6);
-            codeWriter.WriteUInt16(methodRefIndex);
+            codeWriter.WriteByte(0xB6); // invokevirtual
+            codeWriter.WriteUInt16(getResourceMethodRefIndex);
             codeWriter.WriteByte(0x57);
             codeWriter.WriteByte(0xB1);
             codeWriter.WriteUInt16(0);

src/Scanner/__Tests/StellaOps.Scanner.Worker.Tests/EntryTraceExecutionServiceTests.cs

@@ -20,6 +20,7 @@ using StellaOps.Scanner.Surface.Validation;
 using StellaOps.Scanner.Worker.Options;
 using StellaOps.Scanner.Worker.Processing;
 using StellaOps.Scanner.Worker.Tests.TestInfrastructure;
+using StellaOps.Cryptography;
 using Xunit;
 
 namespace StellaOps.Scanner.Worker.Tests;

src/Scanner/__Tests/StellaOps.Scanner.Worker.Tests/SurfaceManifestStageExecutorTests.cs

@@ -8,7 +8,9 @@ using System.Text.Json;
 using System.Text.Json.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Security.Cryptography;
 using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
 using StellaOps.Scanner.Core.Contracts;
 using StellaOps.Scanner.EntryTrace;
 using StellaOps.Scanner.Surface.Env;
@@ -35,7 +37,7 @@ public sealed class SurfaceManifestStageExecutorTests
         using var listener = new WorkerMeterListener();
         listener.Start();
 
-        var hash = new DefaultCryptoHash();
+        var hash = CreateCryptoHash();
         var executor = new SurfaceManifestStageExecutor(
             publisher,
             cache,
@@ -71,7 +73,7 @@ public sealed class SurfaceManifestStageExecutorTests
         using var listener = new WorkerMeterListener();
         listener.Start();
 
-        var hash = new DefaultCryptoHash();
+        var hash = CreateCryptoHash();
         var executor = new SurfaceManifestStageExecutor(
             publisher,
             cache,
@@ -163,7 +165,7 @@ public sealed class SurfaceManifestStageExecutorTests
         var publisher = new TestSurfaceManifestPublisher("tenant-a");
         var cache = new RecordingSurfaceCache();
         var environment = new TestSurfaceEnvironment("tenant-a");
-        var hash = new DefaultCryptoHash();
+        var hash = CreateCryptoHash();
         var executor = new SurfaceManifestStageExecutor(
             publisher,
             cache,
@@ -193,7 +195,8 @@ public sealed class SurfaceManifestStageExecutorTests
         await executor.ExecuteAsync(context, CancellationToken.None);
 
         Assert.Equal(1, publisher.PublishCalls);
-        var request = Assert.NotNull(publisher.LastRequest);
+        Assert.NotNull(publisher.LastRequest);
+        var request = publisher.LastRequest!;
         Assert.Contains(request.Payloads, payload => payload.Kind == "deno.observation");
         Assert.Contains(cache.Entries.Keys, key => key.Namespace == "surface.artifacts.deno.observation");
     }
@@ -361,6 +364,32 @@ public sealed class SurfaceManifestStageExecutorTests
         public IReadOnlyDictionary<string, string> RawVariables { get; } = new Dictionary<string, string>();
     }
 
+    private static ICryptoHash CreateCryptoHash()
+        => new DefaultCryptoHash(new StaticOptionsMonitor<CryptoHashOptions>(new CryptoHashOptions()), NullLogger<DefaultCryptoHash>.Instance);
+
+    private sealed class StaticOptionsMonitor<T> : IOptionsMonitor<T>
+    {
+        public StaticOptionsMonitor(T value)
+        {
+            CurrentValue = value;
+        }
+
+        public T CurrentValue { get; }
+
+        public T Get(string? name) => CurrentValue;
+
+        public IDisposable OnChange(Action<T, string?> listener) => Disposable.Instance;
+
+        private sealed class Disposable : IDisposable
+        {
+            public static readonly Disposable Instance = new();
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+
     private sealed class FakeJobLease : IScanJobLease
     {
         private readonly Dictionary<string, string> _metadata = new()