@reventlessdev/reventless-seed 1.0.0-alpha.1

package/lib/ocaml/Seed_Client.res

@@ -0,0 +1,251 @@
+// GraphQL transport for seeding: authentication, mutation dispatch, and the
+// query helpers a seed run needs to observe what it produced.
+//
+// Everything here is domain-agnostic — it knows about the shapes the framework
+// generates (the CommandResult union, Relay-style connections) but nothing about
+// any particular plugin.
+
+open Seed_Types
+
+// ── Node 18+ globals ────────────────────────────────────────────────────────
+
+type fetchInit = {method: string, headers: dict<string>, body: string}
+type response
+
+@val external fetch: (string, fetchInit) => promise<response> = "fetch"
+@send external responseJson: response => promise<JSON.t> = "json"
+@send external responseText: response => promise<string> = "text"
+@get external responseOk: response => bool = "ok"
+@get external responseStatus: response => int = "status"
+
+@val external setTimeout: (unit => unit, int) => unit = "setTimeout"
+@scope("Date") @val external nowMs: unit => float = "now"
+
+let sleep = (ms: int): promise<unit> => Promise.make((resolve, _) => setTimeout(() => resolve(), ms))
+
+// ── Configuration ───────────────────────────────────────────────────────────
+
+type config = {
+  endpoint: string,
+  loginEndpoint: string,
+  username: string,
+  password: string,
+}
+
+type t = {config: config, mutable token: option<string>}
+
+let make = (~config: config): t => {config, token: None}
+
+/** The bearer token from the last successful `login`, if any — so callers (e.g.
+    Seed.Upload) can authenticate side-channel requests with the same identity. */
+let currentToken = (t: t): option<string> => t.token
+
+// ── JSON helpers ────────────────────────────────────────────────────────────
+
+let field = (json: JSON.t, key: string): option<JSON.t> =>
+  switch json {
+  | Object(obj) => obj->Dict.get(key)
+  | _ => None
+  }
+
+let asString = (json: JSON.t): option<string> =>
+  switch json {
+  | String(s) => Some(s)
+  | _ => None
+  }
+
+/** Reads a string property off a node returned by `queryAllNodes`. */
+let nodeString = (node: JSON.t, key: string): option<string> =>
+  node->field(key)->Option.flatMap(asString)
+
+// ── Requests ────────────────────────────────────────────────────────────────
+
+let login = async (t: t): unit => {
+  let body = JSON.stringify(
+    JSON.Encode.object(
+      Dict.fromArray([
+        ("username", JSON.Encode.string(t.config.username)),
+        ("password", JSON.Encode.string(t.config.password)),
+      ]),
+    ),
+  )
+  let res = try await fetch(
+    t.config.loginEndpoint,
+    {method: "POST", headers: Dict.fromArray([("content-type", "application/json")]), body},
+  ) catch {
+  | _ =>
+    throw(
+      Failed(`login: cannot reach ${t.config.loginEndpoint} — is the platform running?`),
+    )
+  }
+  if !(res->responseOk) {
+    let detail = await res->responseText
+    throw(
+      Failed(
+        `login as "${t.config.username}" failed with HTTP ${(res->responseStatus)
+            ->Int.toString}: ${detail}`,
+      ),
+    )
+  }
+  let json = await res->responseJson
+  t.token = json->field("token")->Option.flatMap(asString)
+}
+
+/**
+ * Sends one GraphQL document and returns its `data`. A GraphQL-level error
+ * aborts the run: a half-seeded store is worse than an empty one, because it
+ * looks like a working dataset.
+ */
+let gql = async (t: t, ~query: string, ~label: string): JSON.t => {
+  let headers = Dict.fromArray([("content-type", "application/json")])
+  switch t.token {
+  | Some(token) => headers->Dict.set("authorization", `Bearer ${token}`)
+  | None => ()
+  }
+  let body = JSON.stringify(
+    JSON.Encode.object(Dict.fromArray([("query", JSON.Encode.string(query))])),
+  )
+  let res = try await fetch(t.config.endpoint, {method: "POST", headers, body}) catch {
+  | _ =>
+    throw(Failed(`${label}: cannot reach ${t.config.endpoint} — is the platform running?`))
+  }
+  let json = await res->responseJson
+  switch json->field("errors") {
+  | Some(errors) =>
+    throw(
+      Failed(`${label} failed\n  query: ${query}\n  response: ${JSON.stringify(errors)}`),
+    )
+  | None => json->field("data")->Option.getOr(JSON.Encode.null)
+  }
+}
+
+// ── Commands ────────────────────────────────────────────────────────────────
+
+let commandResultSelection = `__typename
+  ... on CommandAccepted { eventCount }
+  ... on CommandRejected { errorCode errorDetail }`
+
+/**
+ * Issues one command and insists it was accepted.
+ *
+ * `tolerate` names error codes that are an expected outcome of the domain
+ * rather than a broken seed; a tolerated rejection is returned to the caller so
+ * it can report on them instead of failing.
+ */
+let send = async (t: t, m: mutation, ~tolerate: array<string>=[]): option<string> => {
+  let label = m->describe
+  let query = `mutation { r: ${m.field}(${m.args->renderArgs}) { ${commandResultSelection} } }`
+  let data = await gql(t, ~query, ~label)
+  let result = data->field("r")->Option.getOr(JSON.Encode.null)
+  switch result->nodeString("__typename") {
+  | Some("CommandRejected") =>
+    let code = result->nodeString("errorCode")->Option.getOr("unknown")
+    let detail = result->nodeString("errorDetail")->Option.getOr("none")
+    if tolerate->Array.includes(code) {
+      Some(code)
+    } else {
+      throw(Failed(`${label} was rejected\n  errorCode: ${code}\n  errorDetail: ${detail}`))
+    }
+  | _ => None
+  }
+}
+
+let sendAll = async (t: t, mutations: array<mutation>): unit =>
+  for i in 0 to mutations->Array.length - 1 {
+    switch mutations->Array.get(i) {
+    | Some(m) => (await send(t, m))->ignore
+    | None => ()
+    }
+  }
+
+// ── Queries ─────────────────────────────────────────────────────────────────
+
+/**
+ * Walks a Relay-style connection to the end. Connections page at 50 by default,
+ * so any count taken from a single request silently truncates.
+ */
+let queryAllNodes = async (t: t, ~field as fieldName: string, ~selection: string): array<
+  JSON.t,
+> => {
+  let nodes = []
+  let after = ref(None)
+  let more = ref(true)
+  while more.contents {
+    let cursor = switch after.contents {
+    | Some(c) => `, after: ${quote(c)}`
+    | None => ""
+    }
+    let query = `{ ${fieldName}(first: 100${cursor}) { edges { node { ${selection} } } pageInfo { hasNextPage endCursor } } }`
+    let data = await gql(t, ~query, ~label=fieldName)
+    let connection = data->field(fieldName)->Option.getOr(JSON.Encode.null)
+    switch connection->field("edges") {
+    | Some(Array(edges)) =>
+      edges->Array.forEach(edge =>
+        switch edge->field("node") {
+        | Some(node) => nodes->Array.push(node)
+        | None => ()
+        }
+      )
+    | _ => ()
+    }
+    let pageInfo = connection->field("pageInfo")->Option.getOr(JSON.Encode.null)
+    let hasNext = switch pageInfo->field("hasNextPage") {
+    | Some(Boolean(b)) => b
+    | _ => false
+    }
+    let endCursor = pageInfo->nodeString("endCursor")
+    switch (hasNext, endCursor) {
+    | (true, Some(c)) => after := Some(c)
+    | _ => more := false
+    }
+  }
+  nodes
+}
+
+let countNodes = async (t: t, ~field: string): int =>
+  (await queryAllNodes(t, ~field, ~selection="id"))->Array.length
+
+/**
+ * Polls a `<View>ByIds` field until every id is present.
+ *
+ * Cross-plugin propagation (extension point → extension → command) is
+ * asynchronous, so a seed that places orders immediately after creating
+ * products would race the shadow copy. Waiting on the observable result beats
+ * sleeping and hoping.
+ */
+let waitForIds = async (
+  t: t,
+  ~field as fieldName: string,
+  ~ids: array<string>,
+  ~timeoutMs: int=60000,
+): int => {
+  let deadline = nowMs() +. Int.toFloat(timeoutMs)
+  let idList = ids->Array.map(id => quote(id))->Array.join(", ")
+  let result = ref(None)
+  while result.contents == None {
+    let query = `{ ${fieldName}(ids: [${idList}]) { id } }`
+    let data = await gql(t, ~query, ~label=fieldName)
+    let found = switch data->field(fieldName) {
+    | Some(Array(rows)) => rows
+    | _ => []
+    }
+    if found->Array.length >= ids->Array.length {
+      result := Some(found->Array.length)
+    } else if nowMs() > deadline {
+      let present = found->Array.filterMap(row => row->nodeString("id"))
+      let missing = ids->Array.filter(id => !(present->Array.includes(id)))
+      let shown = missing->Array.slice(~start=0, ~end=10)->Array.join(", ")
+      let extra =
+        missing->Array.length > 10 ? ` (+${(missing->Array.length - 10)->Int.toString} more)` : ""
+      throw(
+        Failed(
+          `only ${(found->Array.length)->Int.toString}/${(ids->Array.length)
+              ->Int.toString} ids reached ${fieldName} within ${timeoutMs->Int.toString}ms.\n  missing: ${shown}${extra}`,
+        ),
+      )
+    } else {
+      await sleep(250)
+    }
+  }
+  result.contents->Option.getOr(0)
+}

package/lib/ocaml/Seed_Random.res

@@ -0,0 +1,80 @@
+// Deterministic pseudo-randomness for reproducible datasets.
+//
+// A seeded generator rather than `Math.random`, so two runs against a fresh
+// store produce identical data — which is what makes a seeded store usable as a
+// baseline for screenshots or comparison.
+
+@scope("Math") @val external imul: (int, int) => int = "imul"
+
+type t = {mutable state: int}
+
+let make = (~seed: int): t => {state: seed}
+
+
+/** mulberry32 — small, fast, and stable across JS engines and Node versions. */
+let float = (r: t): float => {
+  r.state = (r.state + 0x6d2b79f5)->Int.bitwiseOr(0)
+  let a = r.state
+  let b = imul(a->Int.bitwiseXor(a->Int.shiftRightUnsigned(15)), a->Int.bitwiseOr(1))
+  let c = b->Int.bitwiseXor(b + imul(b->Int.bitwiseXor(b->Int.shiftRightUnsigned(7)), b->Int.bitwiseOr(61)))
+  let bits = c->Int.bitwiseXor(c->Int.shiftRightUnsigned(14))
+  // `bits` is a signed 32-bit result; fold the sign bit back in to get the
+  // unsigned value a `>>> 0` would produce.
+  let unsigned = bits < 0 ? Int.toFloat(bits) +. 4294967296.0 : Int.toFloat(bits)
+  unsigned /. 4294967296.0
+}
+
+/** Inclusive on both ends. */
+let int = (r: t, ~min: int, ~max: int): int =>
+  min + Int.fromFloat(float(r) *. Int.toFloat(max - min + 1))
+
+let pick = (r: t, xs: array<'a>): option<'a> =>
+  xs->Array.get(Int.fromFloat(float(r) *. Int.toFloat(xs->Array.length)))
+
+let pickOr = (r: t, ~fallback: 'a, xs: array<'a>): 'a => pick(r, xs)->Option.getOr(fallback)
+
+/**
+ * Weighted sample without replacement.
+ *
+ * Used both for skewing which items are chosen (a few popular ones, a long
+ * tail) and for shuffling — pass equal weights and a count equal to the input
+ * length to get a deterministic permutation.
+ */
+let sampleWeighted = (r: t, entries: array<('a, float)>, ~count: int): array<'a> => {
+  let pool = entries->Array.copy
+  let chosen = []
+  let remaining = count < pool->Array.length ? count : pool->Array.length
+  for _ in 1 to remaining {
+    let total = pool->Array.reduce(0.0, (sum, (_, w)) => sum +. w)
+    let cursor = ref(float(r) *. total)
+    let index = ref(pool->Array.length - 1)
+    let found = ref(false)
+    pool->Array.forEachWithIndex(((_, w), i) => {
+      if !found.contents {
+        cursor := cursor.contents -. w
+        if cursor.contents <= 0.0 {
+          index := i
+          found := true
+        }
+      }
+    })
+    switch pool->Array.get(index.contents) {
+    | Some((item, _)) =>
+      chosen->Array.push(item)
+      pool->Array.splice(~start=index.contents, ~remove=1, ~insert=[])
+    | None => ()
+    }
+  }
+  chosen
+}
+
+/**
+ * Zipf-like weights over an already-ordered array: the first entry carries the
+ * most weight and the tail decays smoothly. `exponent` controls how sharp the
+ * head is — around 1.1 gives a clear leader with a long tail.
+ */
+let zipfWeights = (items: array<'a>, ~exponent: float): array<('a, float)> =>
+  items->Array.mapWithIndex((item, rank) => (
+    item,
+    1.0 /. Math.pow(Int.toFloat(rank + 1), ~exp=exponent),
+  ))

package/lib/ocaml/Seed_Runner.res

@@ -0,0 +1,114 @@
+// Run orchestration: progress output, view verification, and failure reporting.
+
+open Seed_Types
+
+@scope("process") @val external exit: int => unit = "exit"
+@scope("process") @val external env: dict<string> = "env"
+
+let envOr = (key: string, fallback: string): string =>
+  env->Dict.get(key)->Option.getOr(fallback)
+
+/** One line of progress per phase, so a slow run never looks hung. */
+let report = (line: string): unit => Console.log(`  ${line}`)
+
+let heading = (line: string): unit => {
+  Console.log("")
+  Console.log(line)
+}
+
+/**
+ * A view the seed is expected to fill, or one it demonstrably cannot.
+ *
+ * Splitting them matters: an unexpected empty view means the seed missed a
+ * component, which is exactly the "is it broken or is it empty?" ambiguity
+ * seeding exists to remove — so it fails the run. A view listed as unfillable
+ * reports its reason instead, so a zero is never mistaken for a gap.
+ */
+type view =
+  | Seeded(string)
+  | Unfillable(string, string)
+
+let viewName = (v: view): string =>
+  switch v {
+  | Seeded(name) => name
+  | Unfillable(name, _) => name
+  }
+
+/**
+ * Counts every view and fails if one that should have rows is empty.
+ * Returns the counts so callers can fold them into their own summary.
+ */
+let verifyViews = async (client: Seed_Client.t, ~views: array<view>): dict<int> => {
+  let counts = Dict.make()
+  for i in 0 to views->Array.length - 1 {
+    switch views->Array.get(i) {
+    | Some(v) =>
+      let name = v->viewName
+      counts->Dict.set(name, await Seed_Client.countNodes(client, ~field=name))
+    | None => ()
+    }
+  }
+
+  heading("View row counts:")
+  views->Array.forEach(v => {
+    let name = v->viewName
+    let count = counts->Dict.get(name)->Option.getOr(0)
+    let note = switch v {
+    | Unfillable(_, _) => "  (known empty — see warning below)"
+    | Seeded(_) => ""
+    }
+    Console.log(`  ${count->Int.toString->String.padStart(4, " ")}  ${name}${note}`)
+  })
+
+  let empty =
+    views
+    ->Array.filterMap(v =>
+      switch v {
+      | Seeded(name) if counts->Dict.get(name)->Option.getOr(0) == 0 => Some(name)
+      | _ => None
+      }
+    )
+  if empty->Array.length > 0 {
+    throw(Failed(`these views are still empty after seeding: ${empty->Array.join(", ")}`))
+  }
+  counts
+}
+
+/** Collects the reasons for any view that legitimately could not be filled. */
+let unfillableWarnings = (~views: array<view>, ~counts: dict<int>): array<string> =>
+  views->Array.filterMap(v =>
+    switch v {
+    | Unfillable(name, reason) if counts->Dict.get(name)->Option.getOr(0) == 0 =>
+      Some(`${name} is empty: ${reason}.`)
+    | _ => None
+    }
+  )
+
+let warn = (warnings: array<string>): unit =>
+  if warnings->Array.length > 0 {
+    heading("WARNING — the dataset is complete, but not everything could be filled:")
+    warnings->Array.forEach(w => Console.log(`  - ${w}`))
+  }
+
+/**
+ * Wraps a seed run. On failure it prints the cause and exits non-zero, saying
+ * plainly that the store is now half-seeded — recovery is a reset, not a re-run.
+ */
+let run = async (main: unit => promise<unit>): unit =>
+  try await main() catch {
+  | Failed(message) =>
+    Console.error("")
+    Console.error("Seeding aborted — the store is now half-seeded; re-run against a")
+    Console.error("fresh store once the cause below is fixed.")
+    Console.error("")
+    Console.error(message)
+    exit(1)
+  | exn =>
+    Console.error("")
+    Console.error("Seeding aborted with an unexpected error:")
+    Console.error("")
+    Console.error(
+      exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"),
+    )
+    exit(1)
+  }

package/lib/ocaml/Seed_Types.res

@@ -0,0 +1,49 @@
+// Argument values for a seeded mutation, and their GraphQL literal rendering.
+//
+// Seeding sends inline literals rather than declared variables, so any mutation
+// can be called without generating a per-command variable signature. That means
+// values have to know how to render themselves — in particular enums, which are
+// bare identifiers in GraphQL and would be rejected if quoted like strings.
+
+exception Failed(string)
+
+type rec value =
+  | String(string)
+  | Id(string)
+  | Int(int)
+  | Float(float)
+  | Bool(bool)
+  /** Rendered unquoted — GraphQL enum values are identifiers, not strings. */
+  | Enum(string)
+  | List(array<value>)
+  /** A nested GraphQL input object, e.g. a geo-point `{lat, lng}`. Keys are
+      rendered as bare identifiers, as GraphQL input-object fields require. */
+  | Object(array<(string, value)>)
+
+let quote = (s: string): string => JSON.stringify(JSON.Encode.string(s))
+
+let rec toLiteral = (v: value): string =>
+  switch v {
+  | String(s) | Id(s) => quote(s)
+  | Int(i) => i->Int.toString
+  | Float(f) => f->Float.toString
+  | Bool(b) => b ? "true" : "false"
+  | Enum(name) => name
+  | List(items) => `[${items->Array.map(toLiteral)->Array.join(", ")}]`
+  | Object(fields) =>
+    `{${fields->Array.map(((k, v)) => `${k}: ${toLiteral(v)}`)->Array.join(", ")}}`
+  }
+
+let ids = (xs: array<string>): value => List(xs->Array.map(x => Id(x)))
+let strings = (xs: array<string>): value => List(xs->Array.map(x => String(x)))
+
+/** One mutation call: the field name and its inline arguments. */
+type mutation = {field: string, args: array<(string, value)>}
+
+let mutation = (field: string, args: array<(string, value)>): mutation => {field, args}
+
+let renderArgs = (args: array<(string, value)>): string =>
+  args->Array.map(((k, v)) => `${k}: ${toLiteral(v)}`)->Array.join(", ")
+
+/** Human-readable form used in progress output and failure messages. */
+let describe = (m: mutation): string => `${m.field}(${renderArgs(m.args)})`

package/lib/ocaml/Seed_Upload.res

@@ -0,0 +1,99 @@
+// Seed-time asset upload against the framework's presign-shaped upload contract.
+//
+// One code path for both providers: the AWS `Upload_Presign_S3` Function URL and
+// the local dev upload route expose the SAME shape — POST `{fileName,contentType}`
+// → `{uploadUrl, storageRef}`, then PUT the bytes to `uploadUrl`. `uploadAsset`
+// resolves `Ok(storageRef)` — the same same-origin `/{prefix}/{key}` ref a command
+// stores and the UI renders.
+//
+// The seed runs under Node, so the returned `uploadUrl` is resolved to an
+// absolute URL against the endpoint's origin: AWS returns an absolute presigned
+// S3 URL (unchanged), while the local route returns a same-origin relative
+// `/{prefix}/{key}` that Node's `fetch` cannot PUT to until it is made absolute.
+
+type fetchInit = {method: string, headers: dict<string>, body: string}
+type response
+
+@val external fetch: (string, fetchInit) => promise<response> = "fetch"
+@send external responseJson: response => promise<JSON.t> = "json"
+@send external responseText: response => promise<string> = "text"
+@get external responseOk: response => bool = "ok"
+@get external responseStatus: response => int = "status"
+
+// Resolve a possibly-relative URL against a base (WHATWG URL semantics: an
+// absolute `input` ignores `base`, a relative one is resolved against it).
+type url
+@new external makeUrl: (string, string) => url = "URL"
+@get external urlHref: url => string = "href"
+
+let field = (json: JSON.t, key: string): option<JSON.t> =>
+  switch json {
+  | Object(obj) => obj->Dict.get(key)
+  | _ => None
+  }
+
+let asString = (json: JSON.t): option<string> =>
+  switch json {
+  | String(s) => Some(s)
+  | _ => None
+  }
+
+// A `fetch` that reports an unreachable endpoint as `Error` instead of throwing,
+// so the two-step upload can thread failures without exceptions.
+let tryFetch = async (url: string, init: fetchInit): result<response, string> =>
+  try Ok(await fetch(url, init)) catch {
+  | _ => Error(`cannot reach ${url}`)
+  }
+
+/**
+ * Uploads `bytes` under `fileName`/`contentType` through `uploadEndpoint` and
+ * resolves `Ok(storageRef)` (the stored `/{prefix}/{key}` ref), or `Error(msg)`
+ * describing the step that failed. `authToken`, when supplied, is sent as a
+ * Bearer on the presign request (the endpoint decides whether it is required;
+ * the PUT itself is unauthenticated — presigned on AWS, open locally).
+ */
+let uploadAsset = async (
+  ~uploadEndpoint: string,
+  ~bytes: string,
+  ~fileName: string,
+  ~contentType: string,
+  ~authToken: option<string>=?,
+): result<string, string> => {
+  let presignHeaders = Dict.fromArray([("content-type", "application/json")])
+  authToken->Option.forEach(t => presignHeaders->Dict.set("authorization", `Bearer ${t}`))
+  let presignBody = JSON.stringify(
+    JSON.Encode.object(
+      Dict.fromArray([
+        ("fileName", JSON.Encode.string(fileName)),
+        ("contentType", JSON.Encode.string(contentType)),
+      ]),
+    ),
+  )
+
+  switch await tryFetch(uploadEndpoint, {method: "POST", headers: presignHeaders, body: presignBody}) {
+  | Error(m) => Error(`presign: ${m} — is the platform running?`)
+  | Ok(presignRes) if !(presignRes->responseOk) =>
+    let detail = await presignRes->responseText
+    Error(`presign failed with HTTP ${(presignRes->responseStatus)->Int.toString}: ${detail}`)
+  | Ok(presignRes) =>
+    let json = await presignRes->responseJson
+    switch (
+      json->field("uploadUrl")->Option.flatMap(asString),
+      json->field("storageRef")->Option.flatMap(asString),
+    ) {
+    | (Some(uploadUrl), Some(storageRef)) =>
+      let putUrl = urlHref(makeUrl(uploadUrl, uploadEndpoint))
+      switch await tryFetch(
+        putUrl,
+        {method: "PUT", headers: Dict.fromArray([("content-type", contentType)]), body: bytes},
+      ) {
+      | Error(m) => Error(`upload PUT: ${m}`)
+      | Ok(putRes) if putRes->responseOk => Ok(storageRef)
+      | Ok(putRes) =>
+        let detail = await putRes->responseText
+        Error(`upload PUT failed with HTTP ${(putRes->responseStatus)->Int.toString}: ${detail}`)
+      }
+    | _ => Error("presign response missing uploadUrl/storageRef")
+    }
+  }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@reventlessdev/reventless-seed",
+  "version": "1.0.0-alpha.1",
+  "description": "Reusable harness for seeding a Reventless platform through its public GraphQL command API",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "rescript": "12.3.0"
+  },
+  "peerDependencies": {
+    "rescript": "12.3.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ReventlessDev/reventless-core.git",
+    "directory": "reventless/seed"
+  },
+  "scripts": {
+    "build": "rescript build",
+    "start": "rescript watch",
+    "clean": "rescript clean",
+    "rebuild": "pnpm run clean && pnpm run build"
+  }
+}

package/rescript.json

@@ -0,0 +1,20 @@
+{
+  "name": "@reventlessdev/reventless-seed",
+  "package-specs": {
+    "module": "esmodule",
+    "in-source": true
+  },
+  "namespace": "ReventlessSeed",
+  "warnings": {
+    "error": "-44+101"
+  },
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true
+    }
+  ],
+  "dependencies": [],
+  "compiler-flags": [],
+  "suffix": ".res.mjs"
+}