forgeos 0.1.0-alpha.4 → 0.1.0-alpha.41

package/docs/forge-protocol.md

@@ -0,0 +1,189 @@
+# Forge External Runtime Protocol
+
+Forge apps can import and call services written outside TypeScript through a
+`forge.manifest.json` compatible manifest. The manifest is the source of truth
+for external commands and queries:
+
+- validate and import external service metadata;
+- expose external services in generated inspect/API/agent artifacts;
+- execute external commands and queries through the Forge runtime bridge.
+
+This lets Java/Spring, Go, Rust, C#, Python, and other runtimes join the Forge
+contract without requiring the Forge compiler to parse every language AST.
+
+## Manifest
+
+External services publish JSON that matches
+`schemas/forge-manifest.schema.json`.
+
+```json
+{
+  "forgeProtocol": "1.0",
+  "language": "java",
+  "framework": "spring-boot",
+  "service": {
+    "name": "billing",
+    "transport": "http",
+    "baseUrl": "http://localhost:8080",
+    "health": "/actuator/health"
+  },
+  "entries": [
+    {
+      "name": "createInvoice",
+      "kind": "command",
+      "path": "/invoices",
+      "policy": "billing.write",
+      "transaction": "external-managed",
+      "risk": "write",
+      "needsApproval": true,
+      "effects": ["invoice.created"]
+    },
+    {
+      "name": "listInvoices",
+      "kind": "query",
+      "path": "/invoices",
+      "policy": "billing.read",
+      "transaction": "read-only",
+      "risk": "read",
+      "tenantScoped": true
+    }
+  ]
+}
+```
+
+Queries must stay read-only. Commands can declare write, destructive, or
+external risk. Policies are metadata until the runtime bridge enforces them for
+the external transport.
+
+## CLI
+
+Validate a manifest:
+
+```bash
+forge manifest validate ./forge.manifest.json --json
+```
+
+Import or update a service in the app registry:
+
+```bash
+forge manifest import ./forge.manifest.json --json
+```
+
+Imports are stored in `.forge/external-manifests.json`. A root
+`forge.manifest.json` is also discovered automatically for single-service
+experiments.
+
+## Generated Artifacts
+
+After `forge generate`, external services are emitted to:
+
+- `src/forge/_generated/externalServices.json`
+- `src/forge/_generated/api.json` under `external`
+- `src/forge/_generated/agentContract.json`
+- `src/forge/_generated/agentTools.json`
+- `src/forge/_generated/capabilityMap.json`
+
+External auto-tools use `execution: "external-runtime-endpoint"`. Forge exposes
+runtime bridge endpoints for these tools:
+
+```text
+POST /external/:service/commands/:name
+POST /external/:service/queries/:name
+```
+
+The generated client exposes the same bridge through:
+
+```ts
+await client.externalCommand("billing.createInvoice", args);
+await client.externalQuery(api.external.queries["billing.listInvoices"], args);
+```
+
+Command entries can also be invoked from the CLI with a qualified external
+name:
+
+```bash
+forge run billing.createInvoice --args '{"title":"Invoice"}'
+forge query billing.listInvoices --args '{}'
+forge run query billing.listInvoices --args '{}'
+```
+
+## Java Adapter
+
+Forge ships a minimal Java adapter under `adapters/java`. The adapter is a small
+SDK for JVM services that want to join the Forge external runtime protocol
+without requiring Forge to parse Java source code.
+
+```java
+ForgeRegistry app = Forge.service("billing",
+    Forge.framework("java/jdk-http"),
+    Forge.baseUrl("http://127.0.0.1:8788"));
+
+app.command("createInvoice",
+    Forge.handle(CreateInvoiceInput.class, Billing::createInvoice),
+    Forge.policy("billing.manage"),
+    Forge.tenantScoped(true),
+    Forge.needsApproval(true));
+
+app.query("listInvoices",
+    Forge.handle(EmptyInput.class, Billing::listInvoices),
+    Forge.policy("billing.manage"),
+    Forge.tenantScoped(true),
+    Forge.readOnly());
+```
+
+The adapter exposes `GET /manifest`, `GET /health`, `POST /commands/:name`, and
+`POST /queries/:name`. The `examples/java-billing` app demonstrates manifest
+export, HTTP serving, policy enforcement through the Forge bridge, generated
+client calls, and agent tool registration.
+
+Spring Boot users can start from `adapters/java-spring-boot-starter`, which
+provides `@ForgeExternalService`, `@ForgeCommand`, and `@ForgeQuery` annotations
+plus a `ForgeRegistry` auto-configuration hook.
+
+## Runtime Bridge
+
+Forge accepts the normal JSON body:
+
+```json
+{ "args": {} }
+```
+
+For HTTP services, Forge forwards a JSON envelope:
+
+```json
+{
+  "args": {},
+  "auth": { "kind": "user", "userId": "u1", "tenantId": "t1", "role": "member" },
+  "forge": {
+    "service": "billing",
+    "entry": "createInvoice",
+    "kind": "command",
+    "traceId": "trace_..."
+  }
+}
+```
+
+Forge also forwards runtime headers such as `x-forge-trace-id`,
+`x-forge-auth-kind`, `x-forge-user-id`, `x-forge-tenant-id`, `x-forge-role`,
+and the inbound `Authorization` header when present.
+
+External services can return either a Forge envelope:
+
+```json
+{ "ok": true, "result": { "id": "inv_1" } }
+```
+
+or a raw JSON value, which Forge treats as the result for successful HTTP
+responses. Error envelopes should include `ok: false`, `diagnostics`, or
+`error`.
+
+Supported runtime transports:
+
+- `http`: calls `service.baseUrl + entry.path`.
+- `stdio`: starts `service.command`, writes the JSON envelope to stdin, and
+  reads a JSON envelope or raw JSON result from stdout.
+- `grpc`: accepted in manifests for forward compatibility, but not executable
+  by the built-in runtime bridge yet.
+
+Manifest `policy` values are added to Forge policy bindings during generation.
+Use a named Forge policy, or `public`, `user`, or `system`.

package/examples/go-billing/go.mod

@@ -0,0 +1,7 @@
+module github.com/Stahldavid/forge/examples/go-billing
+
+go 1.22
+
+require github.com/Stahldavid/forge/adapters/go v0.0.0
+
+replace github.com/Stahldavid/forge/adapters/go => ../../adapters/go

package/examples/go-billing/main.go

@@ -0,0 +1,120 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"log"
+	"net/http"
+	"os"
+
+	forge "github.com/Stahldavid/forge/adapters/go"
+)
+
+type CreateInvoiceInput struct {
+	Title string `json:"title"`
+}
+
+type Invoice struct {
+	ID       string `json:"id"`
+	Title    string `json:"title,omitempty"`
+	Tenant   string `json:"tenant"`
+	TraceID  string `json:"traceId,omitempty"`
+	AuthKind string `json:"authKind,omitempty"`
+	UserID   string `json:"userId,omitempty"`
+}
+
+func main() {
+	addr := flag.String("addr", "127.0.0.1:8787", "address for the external billing service")
+	baseURL := flag.String("base-url", "", "base URL written into the Forge manifest")
+	manifest := flag.Bool("manifest", false, "write forge.manifest.json to stdout and exit")
+	flag.Parse()
+
+	if *baseURL == "" {
+		*baseURL = "http://" + *addr
+	}
+
+	app := newBillingApp(*baseURL)
+	if *manifest {
+		if err := app.WriteManifest(os.Stdout, *baseURL); err != nil {
+			log.Fatal(err)
+		}
+		return
+	}
+
+	log.Printf("go billing external service listening on http://%s", *addr)
+	if err := http.ListenAndServe(*addr, app.HTTPHandler()); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func newBillingApp(baseURL string) *forge.Registry {
+	app := forge.New("billing",
+		forge.Framework("go/net-http"),
+		forge.BaseURL(baseURL),
+		forge.Health("/health"),
+	)
+
+	app.Command("createInvoice", forge.Handle(createInvoice),
+		forge.Description("Create an invoice in the external Go billing service."),
+		forge.Policy("billing.manage"),
+		forge.TenantScoped(true),
+		forge.TransactionMode(forge.TransactionExternalManaged),
+		forge.EntryRisk(forge.RiskWrite),
+		forge.NeedsApproval(true),
+		forge.Effects("invoice.created"),
+		forge.InputSchema(forge.Object(map[string]any{
+			"title": forge.String(),
+		}, "title")),
+		forge.OutputSchema(invoiceSchema()),
+	)
+
+	app.Query("listInvoices", forge.Handle(listInvoices),
+		forge.Description("List invoices visible to the current tenant."),
+		forge.Policy("billing.manage"),
+		forge.TenantScoped(true),
+		forge.ReadOnly(),
+		forge.OutputSchema(forge.Array(invoiceSchema())),
+	)
+
+	return app
+}
+
+func createInvoice(ctx context.Context, call *forge.Context, input CreateInvoiceInput) (Invoice, error) {
+	if input.Title == "" {
+		return Invoice{}, errors.New("title is required")
+	}
+	if call.Auth.TenantID == "" {
+		return Invoice{}, errors.New("tenant id is required")
+	}
+	return Invoice{
+		ID:       "inv_go_1",
+		Title:    input.Title,
+		Tenant:   call.Auth.TenantID,
+		TraceID:  call.Forge.TraceID,
+		AuthKind: call.Auth.Kind,
+		UserID:   call.Auth.UserID,
+	}, nil
+}
+
+func listInvoices(ctx context.Context, call *forge.Context, input struct{}) ([]Invoice, error) {
+	if call.Auth.TenantID == "" {
+		return nil, errors.New("tenant id is required")
+	}
+	return []Invoice{{
+		ID:     "inv_go_1",
+		Title:  "Go adapter invoice",
+		Tenant: call.Auth.TenantID,
+	}}, nil
+}
+
+func invoiceSchema() forge.Schema {
+	return forge.Object(map[string]any{
+		"id":       forge.String(),
+		"title":    forge.String(),
+		"tenant":   forge.String(),
+		"traceId":  forge.String(),
+		"authKind": forge.String(),
+		"userId":   forge.String(),
+	}, "id", "tenant")
+}

package/examples/java-billing/pom.xml

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>dev.forgeos.examples</groupId>
+  <artifactId>java-billing</artifactId>
+  <version>0.1.0-alpha.11</version>
+  <name>Forge Java Billing Example</name>
+
+  <properties>
+    <maven.compiler.release>17</maven.compiler.release>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>dev.forgeos</groupId>
+      <artifactId>forge-java-adapter</artifactId>
+      <version>0.1.0-alpha.11</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.6.0</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <createDependencyReducedPom>false</createDependencyReducedPom>
+              <shadedArtifactAttached>true</shadedArtifactAttached>
+              <shadedClassifierName>all</shadedClassifierName>
+              <transformers>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                  <mainClass>dev.forgeos.examples.billing.Main</mainClass>
+                </transformer>
+              </transformers>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>

package/examples/java-billing/src/main/java/dev/forgeos/examples/billing/CreateInvoiceInput.java

@@ -0,0 +1,4 @@
+package dev.forgeos.examples.billing;
+
+public record CreateInvoiceInput(String title) {
+}

package/examples/java-billing/src/main/java/dev/forgeos/examples/billing/Invoice.java

@@ -0,0 +1,11 @@
+package dev.forgeos.examples.billing;
+
+public record Invoice(
+    String id,
+    String title,
+    String tenant,
+    String traceId,
+    String authKind,
+    String userId
+) {
+}

package/examples/java-billing/src/main/java/dev/forgeos/examples/billing/Main.java

@@ -0,0 +1,127 @@
+package dev.forgeos.examples.billing;
+
+import com.sun.net.httpserver.HttpServer;
+import dev.forgeos.adapter.Forge;
+import dev.forgeos.adapter.ForgeContext;
+import dev.forgeos.adapter.ForgeHttpHandler;
+import dev.forgeos.adapter.ForgeRegistry;
+import dev.forgeos.adapter.Risk;
+import dev.forgeos.adapter.Schemas;
+import dev.forgeos.adapter.TransactionMode;
+import java.util.Map;
+
+public final class Main {
+  private Main() {
+  }
+
+  public static void main(String[] args) throws Exception {
+    Options options = Options.parse(args);
+    ForgeRegistry app = newBillingApp(options.baseUrl());
+
+    if (options.manifest()) {
+      app.writeManifest(System.out, options.baseUrl());
+      return;
+    }
+
+    String[] addressParts = options.addr().split(":", 2);
+    String host = addressParts[0];
+    int port = Integer.parseInt(addressParts.length > 1 ? addressParts[1] : "8788");
+    HttpServer server = ForgeHttpHandler.listen(app, host, port);
+    System.err.printf("java billing external service listening on http://%s%n", options.addr());
+    Runtime.getRuntime().addShutdownHook(new Thread(() -> server.stop(0)));
+  }
+
+  static ForgeRegistry newBillingApp(String baseUrl) {
+    ForgeRegistry app = Forge.service("billing",
+        Forge.framework("java/jdk-http"),
+        Forge.baseUrl(baseUrl),
+        Forge.health("/health")
+    );
+
+    app.command("createInvoice", Forge.handle(CreateInvoiceInput.class, Main::createInvoice),
+        Forge.description("Create an invoice in the external Java billing service."),
+        Forge.policy("billing.manage"),
+        Forge.tenantScoped(true),
+        Forge.transaction(TransactionMode.EXTERNAL_MANAGED),
+        Forge.risk(Risk.WRITE),
+        Forge.needsApproval(true),
+        Forge.effects("invoice.created"),
+        Forge.inputSchema(Schemas.object(Map.of("title", Schemas.string()), "title")),
+        Forge.outputSchema(invoiceSchema())
+    );
+
+    app.query("listInvoices", Forge.handle(EmptyInput.class, Main::listInvoices),
+        Forge.description("List invoices visible to the current tenant."),
+        Forge.policy("billing.manage"),
+        Forge.tenantScoped(true),
+        Forge.readOnly(),
+        Forge.outputSchema(Schemas.array(invoiceSchema()))
+    );
+
+    return app;
+  }
+
+  static Invoice createInvoice(ForgeContext context, CreateInvoiceInput input) {
+    if (input.title() == null || input.title().isBlank()) {
+      throw new IllegalArgumentException("title is required");
+    }
+    if (context.auth().tenantId() == null || context.auth().tenantId().isBlank()) {
+      throw new IllegalArgumentException("tenant id is required");
+    }
+    return new Invoice(
+        "inv_java_1",
+        input.title(),
+        context.auth().tenantId(),
+        context.forge().traceId(),
+        context.auth().kind(),
+        context.auth().userId()
+    );
+  }
+
+  static Invoice[] listInvoices(ForgeContext context, EmptyInput input) {
+    if (context.auth().tenantId() == null || context.auth().tenantId().isBlank()) {
+      throw new IllegalArgumentException("tenant id is required");
+    }
+    return new Invoice[] {
+        new Invoice("inv_java_1", "Java adapter invoice", context.auth().tenantId(), null, null, null)
+    };
+  }
+
+  static Map<String, Object> invoiceSchema() {
+    return Schemas.object(Map.of(
+        "id", Schemas.string(),
+        "title", Schemas.string(),
+        "tenant", Schemas.string(),
+        "traceId", Schemas.string(),
+        "authKind", Schemas.string(),
+        "userId", Schemas.string()
+    ), "id", "tenant");
+  }
+
+  record EmptyInput() {
+  }
+
+  record Options(String addr, String baseUrl, boolean manifest) {
+    static Options parse(String[] args) {
+      String addr = "127.0.0.1:8788";
+      String baseUrl = null;
+      boolean manifest = false;
+
+      for (int index = 0; index < args.length; index += 1) {
+        String arg = args[index];
+        if ("--manifest".equals(arg)) {
+          manifest = true;
+        } else if ("--addr".equals(arg) && index + 1 < args.length) {
+          addr = args[++index];
+        } else if ("--base-url".equals(arg) && index + 1 < args.length) {
+          baseUrl = args[++index];
+        }
+      }
+
+      if (baseUrl == null || baseUrl.isBlank()) {
+        baseUrl = "http://" + addr;
+      }
+      return new Options(addr, baseUrl, manifest);
+    }
+  }
+}

package/package.json

@@ -1,14 +1,31 @@
 {
   "name": "forgeos",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.41",
   "description": "Agent-native application framework and compiler for building Forge apps without a mandatory dashboard.",
   "type": "module",
+  "license": "MIT",
   "files": [
+    "adapters/",
+    "!adapters/**/target/**",
+    "!adapters/**/*.class",
+    "!adapters/**/*.jar",
     "bin/",
+    "docs/cair-protocol.md",
+    "docs/forge-protocol.md",
+    "examples/go-billing/",
+    "examples/java-billing/",
+    "!examples/**/target/**",
+    "!examples/**/*.class",
+    "!examples/**/*.jar",
     "packages/eslint-plugin-forge/",
+    "schemas/",
     "src/",
+    "!src/forge/_generated/**",
+    "src/forge/_generated/releaseManifest.json",
+    "src/forge/_generated/releaseManifest.ts",
     "templates/",
     "README.md",
+    "LICENSE",
     "CHANGELOG.md",
     "CONTRIBUTING.md",
     "AGENTS.md",
@@ -19,11 +36,16 @@
       "src"
     ]
   },
+  "workspaces": [
+    ".",
+    "packages/*"
+  ],
   "bin": {
     "forge": "bin/forge.mjs"
   },
   "exports": {
     "./react": "./src/forge/react/index.ts",
+    "./vue": "./src/forge/vue/index.ts",
     "./server": "./src/forge/server.ts",
     "./policy": "./src/forge/policy.ts"
   },
@@ -32,12 +54,14 @@
     "build": "tsc --noEmit",
     "typecheck": "tsc --noEmit",
     "changeset": "changeset",
-    "version-packages": "changeset version",
-    "release": "changeset publish --tag alpha",
+    "version-packages": "node scripts/version-packages.mjs",
+    "release": "changeset publish",
     "release:pack": "npm pack --dry-run",
     "release:smoke": "node scripts/smoke-packed-package.mjs",
     "release:evidence": "node scripts/write-release-evidence.mjs",
+    "release:verify-public-alpha": "node scripts/verify-public-alpha.mjs",
     "security:evidence": "node scripts/write-security-evidence.mjs",
+    "security:deps": "node scripts/write-dependency-audit-evidence.mjs",
     "release:publish-alpha": "node scripts/publish-trusted-alpha.mjs",
     "release:publish-local-alpha": "node scripts/publish-local-alpha.mjs",
     "field:test": "node scripts/field-test-forgeos.mjs",
@@ -86,6 +110,7 @@
     "tree-sitter-typescript": "^0.23.2",
     "tsx": "^4.20.6",
     "typescript": "^5.7.3",
+    "vue": "^3.5.38",
     "zod": "^3.25.76"
   },
   "devDependencies": {
@@ -97,5 +122,8 @@
     "@types/react-test-renderer": "^19.1.0",
     "fast-check": "^3.23.2",
     "react-test-renderer": "^19.2.7"
+  },
+  "overrides": {
+    "read-yaml-file": "^3.0.0"
   }
 }

package/schemas/forge-manifest.schema.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://forgeos.dev/schemas/forge-manifest.schema.json",
+  "title": "Forge external runtime manifest",
+  "type": "object",
+  "required": ["forgeProtocol", "language", "service", "entries"],
+  "properties": {
+    "forgeProtocol": { "const": "1.0" },
+    "language": { "type": "string", "minLength": 1 },
+    "framework": { "type": "string", "minLength": 1 },
+    "service": {
+      "type": "object",
+      "required": ["name", "transport"],
+      "properties": {
+        "name": { "type": "string", "minLength": 1 },
+        "transport": { "enum": ["http", "grpc", "stdio"] },
+        "baseUrl": { "type": "string", "minLength": 1 },
+        "command": { "type": "string", "minLength": 1 },
+        "health": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "entries": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["name", "kind"],
+        "properties": {
+          "name": { "type": "string", "minLength": 1 },
+          "kind": { "enum": ["command", "query"] },
+          "description": { "type": "string" },
+          "path": { "type": "string", "minLength": 1 },
+          "method": { "enum": ["GET", "POST"] },
+          "inputSchema": {},
+          "outputSchema": {},
+          "policy": { "type": "string", "minLength": 1 },
+          "tenantScoped": { "type": "boolean" },
+          "transaction": {
+            "enum": ["read-only", "external-managed", "forge-managed", "saga"]
+          },
+          "risk": { "enum": ["read", "write", "destructive", "external"] },
+          "needsApproval": { "type": "boolean" },
+          "effects": {
+            "type": "array",
+            "items": { "type": "string" }
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "schemas": {
+      "type": "object",
+      "additionalProperties": true
+    }
+  },
+  "additionalProperties": false
+}

package/src/forge/_generated/releaseManifest.json

@@ -1,2 +1 @@
-// @forge-generated generator=0.1.0-alpha.4 input=4af795b70ec62dc5967f6e9b78865cfbc8afb09275e575845cf80a360b3b85e2 content=6116e8ec4b5ecea5b4d82b89eab4204402c49dd8a272c345cd340f45cbb179bb
-{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.4","releaseId":"forgeos@0.1.0-alpha.4+unknown","schemaVersion":"0.1.0"}
+{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.41","releaseId":"forgeos@0.1.0-alpha.41+unknown","schemaVersion":"0.1.0"}

package/src/forge/_generated/releaseManifest.ts

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.4 input=4af795b70ec62dc5967f6e9b78865cfbc8afb09275e575845cf80a360b3b85e2 content=61c32102a9e8ac3ff328e692dc0e405359bc4c792779ae745b4300eec18481b8
+// @forge-generated generator=0.1.0-alpha.41 input=472a35507fac4f297d64b66cb443aa712ceb113986ac03317278c6464c17cdd4 content=ba31c1269d2cbbe1fdb5c6dc20de16dabe1afbe97d1af2a72346806ad2d17e16
 export const releaseManifest = {
   "defaultProvider": "local",
   "diagnostics": [],
@@ -19,7 +19,7 @@ export const releaseManifest = {
     "custom"
   ],
   "packageName": "forgeos",
-  "packageVersion": "0.1.0-alpha.4",
-  "releaseId": "forgeos@0.1.0-alpha.4+unknown",
+  "packageVersion": "0.1.0-alpha.41",
+  "releaseId": "forgeos@0.1.0-alpha.41+unknown",
   "schemaVersion": "0.1.0"
 } as const;