@reventlessdev/reventless-core 3.0.0-alpha.166 → 3.0.0-alpha.168

package/tests/api/GraphQL_StitcherTest.res

@@ -1,204 +1,6 @@
 open JestGlobals
 open GraphQL_Stitcher
 
-// A representative stitched schema: admin base (Platform_*) plus two domain
-// plugins (Catalog_*, Ordering_*). 4 Mutation + 4 Query root fields.
-let fullSchemaSdl = `type Node {
-  id: ID!
-}
-
-type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Catalog_updateProduct(input: UpdateInput): Product
-  Ordering_placeOrder(input: OrderInput): Order
-}`
-
-// The exact failure observed in alpha: a lifecycle window collapses the live
-// schema back to admin-base only — every Catalog_*/Ordering_* field gone.
-// 1 Mutation + 2 Query root fields.
-let collapsedSchemaSdl = `type Node {
-  id: ID!
-}
-
-type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-}`
-
-// Real stitched shape: injectAwsAuthAll appends @aws_auth on its own indented
-// line after each Mutation field, so a field spans two physical lines.
-let authAnnotatedSdl = `type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-    @aws_auth(cognito_groups: ["Admin"])
-  Catalog_addProduct(input: AddInput): Product
-    @aws_auth(cognito_groups: ["User"])
-}
-
-type Query {
-  node(id: ID!): Node @aws_auth(cognito_groups: ["Admin"])
-}`
-
-describe("GraphQL_Stitcher.countRootTypeFields", () => {
-  testSync("counts Mutation fields", () => {
-    expect(countRootTypeFields(~sdl=fullSchemaSdl, ~typeName="Mutation"))->toBe(4)
-  })
-  testSync("counts Query fields", () => {
-    expect(countRootTypeFields(~sdl=fullSchemaSdl, ~typeName="Query"))->toBe(4)
-  })
-  testSync("ignores @aws_auth directive lines, counts each Mutation field once", () => {
-    expect(countRootTypeFields(~sdl=authAnnotatedSdl, ~typeName="Mutation"))->toBe(2)
-  })
-  testSync("ignores @aws_auth directive lines, counts each Query field once", () => {
-    expect(countRootTypeFields(~sdl=authAnnotatedSdl, ~typeName="Query"))->toBe(1)
-  })
-  testSync("missing type returns 0", () => {
-    expect(countRootTypeFields(~sdl=fullSchemaSdl, ~typeName="Subscription"))->toBe(0)
-  })
-  testSync("empty SDL returns 0", () => {
-    expect(countRootTypeFields(~sdl="", ~typeName="Mutation"))->toBe(0)
-  })
-})
-
-describe("GraphQL_Stitcher.isCatastrophicSchemaShrink", () => {
-  testSync("rejects the all-disconnected collapse (8 → 3 root fields, < 50%)", () => {
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=fullSchemaSdl, ~newSdl=collapsedSchemaSdl, ~threshold=0.5),
-    )->toBe(true)
-  })
-  testSync("allows an intentional small removal above threshold (8 → 7)", () => {
-    let minusOneSdl = `type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Ordering_placeOrder(input: OrderInput): Order
-}`
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=fullSchemaSdl, ~newSdl=minusOneSdl, ~threshold=0.5),
-    )->toBe(false)
-  })
-  testSync("allows the first push when there is no live schema to protect", () => {
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl="", ~newSdl=fullSchemaSdl, ~threshold=0.5),
-    )->toBe(false)
-  })
-  testSync("allows an unchanged re-push (same SDL)", () => {
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=fullSchemaSdl, ~newSdl=fullSchemaSdl, ~threshold=0.5),
-    )->toBe(false)
-  })
-  testSync("allows a purely additive push even below threshold cardinality", () => {
-    // A tiny live schema growing into a big one drops nothing → never a clobber,
-    // regardless of the ratio.
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=collapsedSchemaSdl, ~newSdl=fullSchemaSdl, ~threshold=0.5),
-    )->toBe(false)
-  })
-  testSync("includes Subscription fields when judging a shrink", () => {
-    let withSubs = `type Query {
-  node(id: ID!): Node
-}
-
-type Mutation {
-  Ordering_placeOrder(input: OrderInput): Order
-}
-
-type Subscription {
-  onOrdering_Customer_Register: Customer
-  onOrdering_Customer_UpdateAddress: Customer
-  onCatalog_Product_Added: Product
-}`
-    // Dropping every Subscription field (and keeping Mutation/Query) is a shrink
-    // the Mutation+Query-only guard would have missed.
-    let subsGone = `type Query {
-  node(id: ID!): Node
-}
-
-type Mutation {
-  Ordering_placeOrder(input: OrderInput): Order
-}`
-    expect(
-      isCatastrophicSchemaShrink(~currentSdl=withSubs, ~newSdl=subsGone, ~threshold=0.5),
-    )->toBe(true)
-  })
-})
-
-describe("GraphQL_Stitcher.rootTypeFieldNames", () => {
-  testSync("lists Mutation field names", () => {
-    expect(rootTypeFieldNames(~sdl=fullSchemaSdl, ~typeName="Mutation"))->toEqual([
-      "Platform_connectPlugin",
-      "Catalog_addProduct",
-      "Catalog_updateProduct",
-      "Ordering_placeOrder",
-    ])
-  })
-  testSync("strips args and @aws_auth directive lines", () => {
-    expect(rootTypeFieldNames(~sdl=authAnnotatedSdl, ~typeName="Mutation"))->toEqual([
-      "Platform_connectPlugin",
-      "Catalog_addProduct",
-    ])
-  })
-  testSync("missing type returns []", () => {
-    expect(rootTypeFieldNames(~sdl=fullSchemaSdl, ~typeName="Subscription"))->toEqual([])
-  })
-})
-
-describe("GraphQL_Stitcher.missingRootFields", () => {
-  testSync("reports plugin fields absent from an admin-base clobber", () => {
-    // The alpha 2026-07-08 clobber: live schema is admin-base only. Every
-    // Catalog_*/Ordering_* field the deploy expects is missing → repair fires.
-    let missing = missingRootFields(~expectedSdl=fullSchemaSdl, ~liveSdl=collapsedSchemaSdl)
-    expect(missing->Array.includes("Catalog_addProduct"))->toBe(true)
-    expect(missing->Array.includes("Ordering_placeOrder"))->toBe(true)
-    expect(missing->Array.includes("Ordering_orders"))->toBe(true)
-  })
-  testSync("empty when live schema is a superset (intact)", () => {
-    expect(missingRootFields(~expectedSdl=fullSchemaSdl, ~liveSdl=fullSchemaSdl))->toEqual([])
-  })
-  testSync("detects an equal-cardinality field swap the count test misses", () => {
-    // Same number of root fields, but one Mutation field replaced by a foreign
-    // one — a swap. countRootTypeFields would report no drift; the name-set diff
-    // catches it.
-    let swapped = `type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Catalog_updateProduct(input: UpdateInput): Product
-  Foreign_strayField(input: OrderInput): Order
-}`
-    // Same count on both sides.
-    expect(countRootTypeFields(~sdl=swapped, ~typeName="Mutation"))->toBe(
-      countRootTypeFields(~sdl=fullSchemaSdl, ~typeName="Mutation"),
-    )
-    // But the expected Ordering_placeOrder is missing from the live (swapped) schema.
-    let missing = missingRootFields(~expectedSdl=fullSchemaSdl, ~liveSdl=swapped)
-    expect(missing->Array.includes("Ordering_placeOrder"))->toBe(true)
-  })
-})
-
 describe("GraphQL_Stitcher.subscriptionSources", () => {
   testSync("encode/decode round-trips the subscription→mutation source mapping", () => {
     let fragment = encode({

package/tests/api/GraphQL_StitcherTest.res.mjs

@@ -3,169 +3,6 @@
 import * as AdminApi$ReventlessCore from "../../src/admin/AdminApi.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "../../src/components/Api/GraphQL_Stitcher.res.mjs";
 
-let fullSchemaSdl = `type Node {
-  id: ID!
-}
-
-type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Catalog_updateProduct(input: UpdateInput): Product
-  Ordering_placeOrder(input: OrderInput): Order
-}`;
-
-let collapsedSchemaSdl = `type Node {
-  id: ID!
-}
-
-type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-}`;
-
-let authAnnotatedSdl = `type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-    @aws_auth(cognito_groups: ["Admin"])
-  Catalog_addProduct(input: AddInput): Product
-    @aws_auth(cognito_groups: ["User"])
-}
-
-type Query {
-  node(id: ID!): Node @aws_auth(cognito_groups: ["Admin"])
-}`;
-
-globalThis.describe("GraphQL_Stitcher.countRootTypeFields", () => {
-  globalThis.test("counts Mutation fields", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Mutation")).toBe(4);
-  });
-  globalThis.test("counts Query fields", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Query")).toBe(4);
-  });
-  globalThis.test("ignores @aws_auth directive lines, counts each Mutation field once", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(authAnnotatedSdl, "Mutation")).toBe(2);
-  });
-  globalThis.test("ignores @aws_auth directive lines, counts each Query field once", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(authAnnotatedSdl, "Query")).toBe(1);
-  });
-  globalThis.test("missing type returns 0", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Subscription")).toBe(0);
-  });
-  globalThis.test("empty SDL returns 0", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields("", "Mutation")).toBe(0);
-  });
-});
-
-globalThis.describe("GraphQL_Stitcher.isCatastrophicSchemaShrink", () => {
-  globalThis.test("rejects the all-disconnected collapse (8 → 3 root fields, < 50%)", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(fullSchemaSdl, collapsedSchemaSdl, 0.5)).toBe(true);
-  });
-  globalThis.test("allows an intentional small removal above threshold (8 → 7)", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(fullSchemaSdl, `type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Ordering_placeOrder(input: OrderInput): Order
-}`, 0.5)).toBe(false);
-  });
-  globalThis.test("allows the first push when there is no live schema to protect", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink("", fullSchemaSdl, 0.5)).toBe(false);
-  });
-  globalThis.test("allows an unchanged re-push (same SDL)", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(fullSchemaSdl, fullSchemaSdl, 0.5)).toBe(false);
-  });
-  globalThis.test("allows a purely additive push even below threshold cardinality", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(collapsedSchemaSdl, fullSchemaSdl, 0.5)).toBe(false);
-  });
-  globalThis.test("includes Subscription fields when judging a shrink", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(`type Query {
-  node(id: ID!): Node
-}
-
-type Mutation {
-  Ordering_placeOrder(input: OrderInput): Order
-}
-
-type Subscription {
-  onOrdering_Customer_Register: Customer
-  onOrdering_Customer_UpdateAddress: Customer
-  onCatalog_Product_Added: Product
-}`, `type Query {
-  node(id: ID!): Node
-}
-
-type Mutation {
-  Ordering_placeOrder(input: OrderInput): Order
-}`, 0.5)).toBe(true);
-  });
-});
-
-globalThis.describe("GraphQL_Stitcher.rootTypeFieldNames", () => {
-  globalThis.test("lists Mutation field names", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(fullSchemaSdl, "Mutation")).toEqual([
-      "Platform_connectPlugin",
-      "Catalog_addProduct",
-      "Catalog_updateProduct",
-      "Ordering_placeOrder"
-    ]);
-  });
-  globalThis.test("strips args and @aws_auth directive lines", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(authAnnotatedSdl, "Mutation")).toEqual([
-      "Platform_connectPlugin",
-      "Catalog_addProduct"
-    ]);
-  });
-  globalThis.test("missing type returns []", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(fullSchemaSdl, "Subscription")).toEqual([]);
-  });
-});
-
-globalThis.describe("GraphQL_Stitcher.missingRootFields", () => {
-  globalThis.test("reports plugin fields absent from an admin-base clobber", () => {
-    let missing = GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, collapsedSchemaSdl);
-    globalThis.expect(missing.includes("Catalog_addProduct")).toBe(true);
-    globalThis.expect(missing.includes("Ordering_placeOrder")).toBe(true);
-    globalThis.expect(missing.includes("Ordering_orders")).toBe(true);
-  });
-  globalThis.test("empty when live schema is a superset (intact)", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, fullSchemaSdl)).toEqual([]);
-  });
-  globalThis.test("detects an equal-cardinality field swap the count test misses", () => {
-    let swapped = `type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Catalog_updateProduct(input: UpdateInput): Product
-  Foreign_strayField(input: OrderInput): Order
-}`;
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(swapped, "Mutation")).toBe(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Mutation"));
-    let missing = GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, swapped);
-    globalThis.expect(missing.includes("Ordering_placeOrder")).toBe(true);
-  });
-});
-
 globalThis.describe("GraphQL_Stitcher.subscriptionSources", () => {
   globalThis.test("encode/decode round-trips the subscription→mutation source mapping", () => {
     let fragment = GraphQL_Stitcher$ReventlessCore.encode({
@@ -272,9 +109,4 @@ globalThis.describe("GraphQL_Stitcher.stitchStandalone", () => {
   });
 });
 
-export {
-  fullSchemaSdl,
-  collapsedSchemaSdl,
-  authAnnotatedSdl,
-}
 /*  Not a pure module */

package/src/admin/ApiFragmentRegistry/ApiFragmentRegistryBehavior.res

@@ -1,108 +0,0 @@
-@@reventless.behavior(ApiFragmentRegistrySpec)
-
-// NOTE: no `open Reventless.Plugin` — it would shadow the `encoded`/`protocol` labels reused
-// below when building the fragment snapshot (warning 45). The two Plugin types are qualified.
-
-// The current fragment for a plugin name plus its target API and the last recorded push
-// outcome (kept only to dedupe at-least-once redelivery of RecordApiFragmentPush).
-type registryEntry = {
-  fragment: Reventless.Plugin.apiSchemaFragment,
-  apiTarget: Reventless.Plugin.apiTarget,
-  lastPush: option<(bool, string, string)>, // (ok, message, at)
-}
-
-// Singleton aggregate: the WHOLE registry, keyed by pluginId, in one consistency boundary.
-type state = {entries: dict<registryEntry>}
-
-let initialState = {entries: Dict.make()}
-
-// Framework-internal aggregate outside an Aggregate/ folder — the Behavior.T snapshot/counter
-// fields are satisfied manually (mirrors PluginBehavior). The registry's history is short
-// (deploy-frequency writes), so persisted snapshots would buy nothing.
-let snapshot = None
-let atomicCounter = None
-
-// Immutable dict updates (no reliance on Dict.copy/Dict.delete): rebuild via toArray/fromArray
-// so evolve never mutates the replayed state.
-let entriesWith = (entries: dict<registryEntry>, pluginId, entry) =>
-  entries
-  ->Dict.toArray
-  ->Array.filter(((k, _)) => k != pluginId)
-  ->Array.concat([(pluginId, entry)])
-  ->Dict.fromArray
-
-let entriesWithout = (entries: dict<registryEntry>, pluginId) =>
-  entries->Dict.toArray->Array.filter(((k, _)) => k != pluginId)->Dict.fromArray
-
-let evolve = (state, event) =>
-  switch event {
-  | ApiFragmentRegistered({pluginId, fragment, apiTarget}) => {
-      entries: state.entries->entriesWith(pluginId, {fragment, apiTarget, lastPush: None}),
-    }
-  | ApiFragmentUpdated({pluginId, newFragment, apiTarget}) => {
-      entries: state.entries->entriesWith(pluginId, {fragment: newFragment, apiTarget, lastPush: None}),
-    }
-  | ApiFragmentDeregistered({pluginId}) => {entries: state.entries->entriesWithout(pluginId)}
-  | ApiFragmentPushRecorded({pluginId, ok, message, at}) =>
-    switch state.entries->Dict.get(pluginId) {
-    | Some(entry) => {
-        entries: state.entries->entriesWith(pluginId, {...entry, lastPush: Some((ok, message, at))}),
-      }
-    | None => state
-    }
-  // Derived echo — no fold change.
-  | ApiSchemaComputed(_) => state
-  }
-
-// The consistent registry snapshot AFTER the triggering change — one entry per registered plugin.
-let snapshotOf = (entries: dict<registryEntry>): array<ApiFragmentRegistrySpec.fragmentSnapshotEntry> =>
-  entries
-  ->Dict.toArray
-  ->Array.map(((pluginId, e)) => {
-    ApiFragmentRegistrySpec.pluginId,
-    encoded: e.fragment.encoded,
-    protocol: e.fragment.protocol,
-    apiTarget: e.apiTarget,
-  })
-
-// Emit the fact event plus ApiSchemaComputed{snapshot} folded from the POST-change state, so the
-// reactive push SideEffect stitches from consistent state. Idempotent no-ops emit nothing (and
-// therefore no push). RecordApiFragmentPush records the outcome only — it changes no fragments,
-// so it emits no ApiSchemaComputed (which also avoids a recompute loop).
-let decide = (state, command) => {
-  let withSchema = (fact: ApiFragmentRegistrySpec.event) => {
-    let next = evolve(state, fact)
-    Ok([fact, ApiSchemaComputed({snapshot: snapshotOf(next.entries)})])
-  }
-  switch command {
-  | RegisterApiFragment({pluginId, fragment, apiTarget, at}) =>
-    switch state.entries->Dict.get(pluginId) {
-    | None => withSchema(ApiFragmentRegistered({pluginId, fragment, apiTarget, at}))
-    // Idempotent: an unchanged re-registration (same fragment AND same target — a redeploy
-    // carrying the same schema, or a version supersession that didn't change the SDL) emits
-    // nothing. A target change with an identical fragment IS meaningful (the fields move between
-    // the Domain and Platform APIs), so it is not a no-op.
-    | Some({fragment: current, apiTarget: currentTarget})
-      if current == fragment && currentTarget == apiTarget =>
-      Ok([])
-    | Some({fragment: current}) =>
-      withSchema(
-        ApiFragmentUpdated({pluginId, previousFragment: current, newFragment: fragment, apiTarget, at}),
-      )
-    }
-  | DeregisterApiFragment({pluginId}) =>
-    switch state.entries->Dict.get(pluginId) {
-    | None => Ok([]) // idempotent — nothing registered
-    | Some(_) => withSchema(ApiFragmentDeregistered({pluginId: pluginId}))
-    }
-  | RecordApiFragmentPush({pluginId, ok, message, at}) =>
-    switch state.entries->Dict.get(pluginId) {
-    | None => Ok([]) // fragment deregistered in the meantime — nowhere to record
-    // Idempotent: an at-least-once redelivery carries the identical payload.
-    | Some({lastPush: Some((lastOk, lastMessage, lastAt))})
-      if lastOk == ok && lastMessage == message && lastAt == at =>
-      Ok([])
-    | Some(_) => Ok([ApiFragmentPushRecorded({pluginId, ok, message, at})])
-    }
-  }
-}

package/src/admin/ApiFragmentRegistry/ApiFragmentRegistryBehavior.res.mjs

@@ -1,190 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
-
-let initialState = {
-  entries: {}
-};
-
-function entriesWith(entries, pluginId, entry) {
-  return Object.fromEntries(Object.entries(entries).filter(param => param[0] !== pluginId).concat([[
-      pluginId,
-      entry
-    ]]));
-}
-
-function entriesWithout(entries, pluginId) {
-  return Object.fromEntries(Object.entries(entries).filter(param => param[0] !== pluginId));
-}
-
-function evolve(state, event) {
-  switch (event.TAG) {
-    case "ApiFragmentRegistered" :
-      return {
-        entries: entriesWith(state.entries, event.pluginId, {
-          fragment: event.fragment,
-          apiTarget: event.apiTarget,
-          lastPush: undefined
-        })
-      };
-    case "ApiFragmentUpdated" :
-      return {
-        entries: entriesWith(state.entries, event.pluginId, {
-          fragment: event.newFragment,
-          apiTarget: event.apiTarget,
-          lastPush: undefined
-        })
-      };
-    case "ApiFragmentDeregistered" :
-      return {
-        entries: entriesWithout(state.entries, event.pluginId)
-      };
-    case "ApiFragmentPushRecorded" :
-      let pluginId = event.pluginId;
-      let entry = state.entries[pluginId];
-      if (entry !== undefined) {
-        return {
-          entries: entriesWith(state.entries, pluginId, {
-            fragment: entry.fragment,
-            apiTarget: entry.apiTarget,
-            lastPush: [
-              event.ok,
-              event.message,
-              event.at
-            ]
-          })
-        };
-      } else {
-        return state;
-      }
-    case "ApiSchemaComputed" :
-      return state;
-  }
-}
-
-function snapshotOf(entries) {
-  return Object.entries(entries).map(param => {
-    let e = param[1];
-    return {
-      pluginId: param[0],
-      encoded: e.fragment.encoded,
-      protocol: e.fragment.protocol,
-      apiTarget: e.apiTarget
-    };
-  });
-}
-
-function decide(state, command) {
-  let withSchema = fact => {
-    let next = evolve(state, fact);
-    return {
-      TAG: "Ok",
-      _0: [
-        fact,
-        {
-          TAG: "ApiSchemaComputed",
-          snapshot: snapshotOf(next.entries)
-        }
-      ]
-    };
-  };
-  switch (command.TAG) {
-    case "RegisterApiFragment" :
-      let at = command.at;
-      let apiTarget = command.apiTarget;
-      let fragment = command.fragment;
-      let pluginId = command.pluginId;
-      let match = state.entries[pluginId];
-      if (match === undefined) {
-        return withSchema({
-          TAG: "ApiFragmentRegistered",
-          pluginId: pluginId,
-          fragment: fragment,
-          apiTarget: apiTarget,
-          at: at
-        });
-      }
-      let current = match.fragment;
-      if (Primitive_object.equal(current, fragment) && match.apiTarget === apiTarget) {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      } else {
-        return withSchema({
-          TAG: "ApiFragmentUpdated",
-          pluginId: pluginId,
-          previousFragment: current,
-          newFragment: fragment,
-          apiTarget: apiTarget,
-          at: at
-        });
-      }
-    case "DeregisterApiFragment" :
-      let pluginId$1 = command.pluginId;
-      let match$1 = state.entries[pluginId$1];
-      if (match$1 !== undefined) {
-        return withSchema({
-          TAG: "ApiFragmentDeregistered",
-          pluginId: pluginId$1
-        });
-      } else {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      }
-    case "RecordApiFragmentPush" :
-      let at$1 = command.at;
-      let message = command.message;
-      let ok = command.ok;
-      let pluginId$2 = command.pluginId;
-      let match$2 = state.entries[pluginId$2];
-      if (match$2 === undefined) {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      }
-      let match$3 = match$2.lastPush;
-      if (match$3 !== undefined && match$3[0] === ok && match$3[1] === message && match$3[2] === at$1) {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      }
-      return {
-        TAG: "Ok",
-        _0: [{
-            TAG: "ApiFragmentPushRecorded",
-            pluginId: pluginId$2,
-            ok: ok,
-            message: message,
-            at: at$1
-          }]
-      };
-      break;
-  }
-}
-
-let Spec;
-
-let snapshot;
-
-let atomicCounter;
-
-let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/ApiFragmentRegistryBehavior.res.mjs";
-
-export {
-  Spec,
-  initialState,
-  snapshot,
-  atomicCounter,
-  entriesWith,
-  entriesWithout,
-  evolve,
-  snapshotOf,
-  decide,
-  moduleUrl,
-}
-/* No side effect */