@pmelab/gtd 27.1.0 → 27.3.0

package/src/workflows/shared/health.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest"
 import { toRequest } from "../../judges/index.js"
+import { testRepo } from "../../testkit/index.js"
 import { retryQuestion } from "./health.js"
 
 describe("retryQuestion", () => {
@@ -11,3 +12,105 @@ describe("retryQuestion", () => {
     ).toBeGreaterThanOrEqual(2)
   })
 })
+
+type W = { write(p: string, c: string): void }
+
+describe("gate guard", () => {
+  const config = (guard: string) =>
+    [
+      `import { gate } from "@pmelab/gtd/workflows"`,
+      `import { agent, refuse } from "@pmelab/gtd/flows"`,
+      `export const held = async () => { await agent("first", "go"); ${guard}; await gate("suite", "fix it", guard) }`,
+      `export default held`,
+    ].join("\n")
+
+  const red = {
+    first: (_: unknown, r: W) => r.write("f", "1\n"),
+    "suite.check": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", "red\n"),
+  }
+
+  it("runs the guard after a blocked landing and lets its refusal stop it", async () => {
+    const repo = testRepo({
+      workflow: config('const guard = () => { refuse("guarded: nope") }'),
+      env: { GTD_TEST_COMMAND: "true" },
+    })
+    await repo.start("held")
+    await repo.drive(red)
+    await expect(repo.drive({ "suite.blocked": (_, r) => r.write("x", "1\n") })).rejects.toThrow(
+      "guarded: nope",
+    )
+  })
+
+  it("never runs the guard after the check step", async () => {
+    const repo = testRepo({
+      workflow: config('const guard = () => { refuse("guarded: nope") }'),
+      env: { GTD_TEST_COMMAND: "true" },
+    })
+    await repo.start("held")
+    const rest = await repo.drive(red)
+    expect(rest.state).toBe("suite.blocked")
+  })
+})
+
+describe("healthy describeGuard", () => {
+  const config = (options: string) =>
+    [
+      `import { healthy } from "@pmelab/gtd/workflows"`,
+      `import { agent, read, refuse } from "@pmelab/gtd/flows"`,
+      `const describeGuard = () => { refuse("describe-guarded: nope") }`,
+      `const guard = () => { refuse("guarded: nope") }`,
+      `export const held = async () => { await agent("first", "go"); await healthy(() => agent("fix", "go"), ${options}) }`,
+      `export default held`,
+    ].join("\n")
+
+  let runs = 0
+  const handlers = (extra: Record<string, unknown>) => ({
+    "health.check": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", `red ${runs++}\n`),
+    "health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
+    fix: (_: unknown, r: W) => r.write("f", `${runs}\n`),
+    first: (_: unknown, r: W) => r.write("start", "1\n"),
+    ...extra,
+  })
+  const make = (options: string) =>
+    testRepo({ workflow: config(options), env: { GTD_TEST_COMMAND: "true" } })
+
+  it("runs after a describe landing and its refusal stops the turn", async () => {
+    runs = 0
+    const repo = make("{ describeGuard }")
+    await repo.start("held")
+    await expect(repo.drive(handlers({ "health.describe": () => undefined }))).rejects.toThrow(
+      "describe-guarded: nope",
+    )
+  })
+
+  it("never runs after the human stop rest", async () => {
+    runs = 0
+    // Refuses only once a person's edit exists, which only a post-stop run can see.
+    const repo = make(
+      '{ describeGuard: () => { if (read("human.txt") !== undefined) refuse("describe-guarded: late") } }',
+    )
+    await repo.start("held")
+    const rest = await repo.drive(handlers({ "health.describe": () => undefined }))
+    expect(rest.state).toBe("health.stop")
+    const after = await repo.drive(
+      handlers({ "health.stop": (_: unknown, r: W) => r.write("human.txt", "edit\n") }),
+    )
+    expect(after.state).not.toBe("health.stop")
+  })
+
+  it("keeps guard running after describe", async () => {
+    runs = 0
+    // Refuses only once the describe turn has written its analysis.
+    const repo = make(
+      '{ guard: () => { if (read(".gtd/ESCALATION.md") !== undefined) refuse("guarded: nope") } }',
+    )
+    await repo.start("held")
+    await expect(
+      repo.drive(
+        handlers({
+          "health.describe": (_: unknown, r: W) => r.write(".gtd/ESCALATION.md", "why\n"),
+        }),
+      ),
+    ).rejects.toThrow("guarded: nope")
+  })
+})

package/src/workflows/shared/health.ts

@@ -28,13 +28,30 @@ const escalationSteps: kit.EscalationSteps = {
   exhausted: escalationExhausted,
 }
 
+/** Runs after an agent or human turn; refuses it by throwing (`refuse`). */
+export type Guard = () => void
+
+export const guarded =
+  <A extends unknown[]>(turn: (...a: A) => Promise<void>, guard?: Guard) =>
+  async (...a: A): Promise<void> => {
+    await turn(...a)
+    guard?.()
+  }
+
+const guardedSteps = (guard?: Guard, describeGuard?: Guard): kit.EscalationSteps => ({
+  limit: escalationSteps.limit,
+  describe: guarded(guarded(escalationSteps.describe, guard), describeGuard),
+  stop: guarded(escalationSteps.stop, guard),
+  exhausted: guarded(escalationSteps.exhausted, guard),
+})
+
 /**
  * Hand a red suite that repeated attempts could not fix to a person: an
  * agent writes `.gtd/ESCALATION.md`, a human narrows it. From the third round
  * on, the human is told the budget is spent instead.
  */
-export const escalation = (count: kit.EscalationCount): Promise<void> =>
-  kit.escalation(count, escalationSteps)
+export const escalation = (count: kit.EscalationCount, guard?: Guard): Promise<void> =>
+  kit.escalation(count, guardedSteps(guard))
 
 /** "Is this red round the same failure as the last one?" — asked of two reports, or of nothing when one is empty. */
 export const retryQuestion = (comparable: boolean): JudgeQuestion =>
@@ -79,6 +96,10 @@ export interface HealthOptions {
   readonly escalations?: kit.EscalationCount
   /** Paths removed on a green run. */
   readonly sweepOnGreen?: readonly string[]
+  /** Runs after every fix and escalation turn. */
+  readonly guard?: Guard | undefined
+  /** Runs after the escalation's agent turn only; the human rests stay unguarded. */
+  readonly describeGuard?: Guard | undefined
 }
 
 const runSuite = (options: HealthOptions): Promise<boolean> =>
@@ -95,20 +116,24 @@ const runSuite = (options: HealthOptions): Promise<boolean> =>
  * identical to the previous round's.
  */
 export const healthy = (fix: () => Promise<void>, options: HealthOptions = {}): Promise<void> =>
-  kit.healthy(fix, {
+  kit.healthy(guarded(fix, options.guard), {
     check: () => runSuite(options),
     report: FEEDBACK,
     fixCap: FIX_CAP,
     fixesSoFar: options.fixesSoFar ?? 0,
     sameFailure,
     escalations: options.escalations ?? { rounds: 0 },
-    escalation: escalationSteps,
+    escalation: guardedSteps(options.guard, options.describeGuard),
   })
 
-/** Hold the process at `<name>.blocked` until the suite is green. */
-export const gate = (name: string, message: string): Promise<void> =>
+/**
+ * Hold the process at `<name>.blocked` until the suite is green. `guard` runs
+ * after each `blocked` landing only — never after a check, whose refusal would
+ * re-run the same script forever.
+ */
+export const gate = (name: string, message: string, guard?: Guard): Promise<void> =>
   kit.gate(
     name,
     () => baseline("check"),
-    () => human("blocked", { message, label: "Baseline is red", file: FEEDBACK }),
+    guarded(() => human("blocked", { message, label: "Baseline is red", file: FEEDBACK }), guard),
   )

package/src/workflows/shared/options.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, it } from "vitest"
 import { configure } from "../../flows/index.js"
 import * as workflows from "../index.js"
+import * as options from "./options.js"
 
 const { defaults, envDefaults, feature, fix, review, ShippedOptions } = workflows
+const { flagShipped } = options
 
 describe("the shipped workflow factories", () => {
   it("take exactly the settings the shipped workflows declare as options", () => {
@@ -30,6 +32,14 @@ describe("the shipped workflow factories", () => {
     })
   })
 
+  it("default refactorFlagPattern to GTD_FLAG_ matches and let a factory override win", () => {
+    expect(defaults.refactorFlagPattern).toBe("\\bGTD_FLAG_\\w+")
+    expect(configure(feature({ refactorFlagPattern: "\\bFF_\\w+" }))).toMatchObject({
+      ok: true,
+      build: { defaults: { refactorFlagPattern: "\\bFF_\\w+" } },
+    })
+  })
+
   it("build the shipped settings unchanged with no options", () => {
     for (const factory of [feature, fix, review]) {
       expect(configure(factory)).toMatchObject({ ok: true, build: { defaults, envDefaults } })
@@ -57,4 +67,24 @@ describe("the shipped workflow factories", () => {
     const result = configure(fix({ judgeBudgetBytes: 65536 }))
     expect(result).toMatchObject({ ok: false, issues: [{ path: ["judgeBudgetBytes"] }] })
   })
+
+  describe("flagShipped", () => {
+    const factory = flagShipped(async () => {})
+
+    it("declare flag and flagRegistry as process settings, so --var flag= is accepted", () => {
+      expect(configure(factory)).toMatchObject({
+        ok: true,
+        build: {
+          defaults: { ...defaults, flag: "", flagRegistry: "src/flags/index.ts" },
+          envDefaults,
+        },
+      })
+    })
+
+    it("fail the load on an unknown option", () => {
+      // @ts-expect-error — `flag` is a --var, not an option
+      const result = configure(factory({ flag: "x" }))
+      expect(result).toMatchObject({ ok: false, issues: [{ path: ["flag"] }] })
+    })
+  })
 })

package/src/workflows/shared/options.ts

@@ -16,6 +16,7 @@ export const ShippedOptions = Schema.Struct({
   judgeIdenticalMinP: setting,
   reviewNoteActionable: setting,
   reviewSeverityMinP: setting,
+  refactorFlagPattern: setting,
   qualityReviews: setting,
   testCommand: setting,
   plannerModel: setting,
@@ -48,3 +49,22 @@ export const shipped = (
       base,
     }),
   )
+
+export const FlagOptions = Schema.Struct({ ...ShippedOptions.fields, flagRegistry: setting })
+
+export type FlagOptions = Schema.Schema.Encoded<typeof FlagOptions>
+
+export const flagShipped = (flow: Flow): WorkflowFactory<FlagOptions> =>
+  defineWorkflow(
+    Schema.standardSchemaV1(FlagOptions, { onExcessProperty: "error", errors: "all" }),
+    (options) => {
+      const flagDefaults = { ...defaults, flag: "", flagRegistry: "src/flags/index.ts" }
+      return {
+        flow,
+        defaults: over(flagDefaults, options),
+        envDefaults: over(envDefaults, options),
+        doors: {},
+        base: undefined,
+      }
+    },
+  )

package/src/workflows/shared/registry.test.ts

@@ -0,0 +1,305 @@
+import { afterEach, describe, expect, it } from "vitest"
+import { installContext } from "../../flows/index.js"
+import { flagReferences, flipProblems, registryEntry, requireFlag } from "./registry.js"
+
+const ONE_LINE = `export const FLAGS = [
+  { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
+  { name: "beta", owner: "b", expiry: "2027-02-01", kind: "release", defaultOn: true },
+  { name: "gamma", owner: "c", expiry: "2027-03-01", kind: "ops" },
+] as const
+`
+
+const WRAPPED = `export const FLAGS = [
+  {
+    name: "alpha",
+    owner: "a",
+    expiry: "2027-01-01",
+    kind: "release",
+  },
+  {
+    name: "beta",
+    owner: "b",
+    expiry: "2027-02-01",
+    kind: "release",
+    defaultOn: true,
+  },
+] as const
+`
+
+describe("registryEntry", () => {
+  it("finds name, kind and defaultOn in a one-line entry", () => {
+    expect(registryEntry(ONE_LINE, "alpha")).toEqual({
+      kind: "release",
+      defaultOn: false,
+    })
+    expect(registryEntry(ONE_LINE, "beta")).toEqual({
+      kind: "release",
+      defaultOn: true,
+    })
+    expect(registryEntry(ONE_LINE, "gamma")?.kind).toBe("ops")
+  })
+
+  it("finds them in an oxfmt-wrapped entry", () => {
+    expect(registryEntry(WRAPPED, "alpha")).toEqual({
+      kind: "release",
+      defaultOn: false,
+    })
+    expect(registryEntry(WRAPPED, "beta")?.defaultOn).toBe(true)
+  })
+
+  it("is undefined for an unknown name", () => {
+    expect(registryEntry(ONE_LINE, "delta")).toBeUndefined()
+  })
+
+  it("ignores a kind inside a block comment ahead of the real one", () => {
+    const text = 'export const FLAGS = [{ name: "alpha", /* kind: "ops" */ kind: "release" }]'
+    expect(registryEntry(text, "alpha")?.kind).toBe("release")
+  })
+
+  it("reads no kind from one with no closing quote", () => {
+    const text = 'export const FLAGS = [{ name: "alpha", kind: "release-candidate" }]'
+    expect(registryEntry(text, "alpha")?.kind).toBe("")
+  })
+
+  it("reads the kind right after a comment with no space between", () => {
+    const text = 'export const FLAGS = [{ name: "alpha", /*x*/kind: "release" }]'
+    expect(registryEntry(text, "alpha")?.kind).toBe("release")
+  })
+
+  it("ignores a kind inside a line comment on a prior line", () => {
+    const text =
+      'export const FLAGS = [{\n  name: "alpha",\n  // kind: "ops"\n  kind: "release",\n}]'
+    expect(registryEntry(text, "alpha")?.kind).toBe("release")
+  })
+
+  it("ignores a kind inside a string ahead of the real one", () => {
+    const text = `export const FLAGS = [{ name: "alpha", owner: "kind: 'ops'", kind: "release" }]`
+    expect(registryEntry(text, "alpha")?.kind).toBe("release")
+  })
+})
+
+describe("flipProblems", () => {
+  it("is empty when defaultOn is added to the named entry", () => {
+    const after = ONE_LINE.replace(
+      'kind: "release" },\n  { name: "beta"',
+      'kind: "release", defaultOn: true },\n  { name: "beta"',
+    )
+    expect(after).not.toBe(ONE_LINE)
+    expect(flipProblems(ONE_LINE, after, "alpha")).toEqual([])
+  })
+
+  it("is empty when false flips to true", () => {
+    const before = ONE_LINE.replace('kind: "release" },', 'kind: "release", defaultOn: false },')
+    const after = ONE_LINE.replace('kind: "release" },', 'kind: "release", defaultOn: true },')
+    expect(flipProblems(before, after, "alpha")).toEqual([])
+  })
+
+  it("ignores re-wrapping and a trailing comma inside the entry", () => {
+    const after = WRAPPED.replace(
+      'kind: "release",\n  },',
+      'kind: "release",\n    defaultOn: true,\n  },',
+    )
+    expect(flipProblems(WRAPPED, after, "alpha")).toEqual([])
+    const oneLiner = ONE_LINE.replace(
+      'kind: "release" },\n  { name: "beta"',
+      'kind: "release", defaultOn: true, },\n  { name: "beta"',
+    )
+    expect(flipProblems(ONE_LINE, oneLiner, "alpha")).toEqual([])
+  })
+
+  describe("with a non-BMP character in the entry", () => {
+    const EMOJI =
+      'export const FLAGS = [\n  { name: "alpha", owner: "Team 🚀", kind: "release" },\n]'
+
+    it("is empty for an oxfmt re-wrap with a trailing comma", () => {
+      const after =
+        'export const FLAGS = [\n  {\n    name: "alpha",\n    owner: "Team 🚀",\n    kind: "release",\n    defaultOn: true,\n  },\n]'
+      expect(flipProblems(EMOJI, after, "alpha")).toEqual([])
+    })
+
+    it("faults an out-of-scope edit to a field after the emoji", () => {
+      const before =
+        'export const FLAGS = [\n  { name: "alpha", owner: "Team 🚀", kind: " release", defaultOn: false },\n]'
+      const after =
+        'export const FLAGS = [\n  { name: "alpha", owner: "Team 🚀", kind: "release", defaultOn: true },\n]'
+      expect(flipProblems(before, after, "alpha")).toContain(
+        'entry "alpha" changed beyond defaultOn',
+      )
+    })
+  })
+
+  it("faults a change to a second entry", () => {
+    const after = ONE_LINE.replace(
+      'kind: "release" },',
+      'kind: "release", defaultOn: true },',
+    ).replace('owner: "c"', 'owner: "z"')
+    expect(flipProblems(ONE_LINE, after, "alpha")).not.toEqual([])
+  })
+
+  it("faults an owner or expiry change inside the entry", () => {
+    const owner = ONE_LINE.replace(
+      'owner: "a", expiry: "2027-01-01", kind: "release"',
+      'owner: "q", expiry: "2027-01-01", kind: "release", defaultOn: true',
+    )
+    const expiry = ONE_LINE.replace(
+      'owner: "a", expiry: "2027-01-01", kind: "release"',
+      'owner: "a", expiry: "2030-01-01", kind: "release", defaultOn: true',
+    )
+    expect(flipProblems(ONE_LINE, owner, "alpha")).not.toEqual([])
+    expect(flipProblems(ONE_LINE, expiry, "alpha")).not.toEqual([])
+  })
+
+  it("faults a comment outside the entry", () => {
+    const after = `// note\n${ONE_LINE.replace('kind: "release" },', 'kind: "release", defaultOn: true },')}`
+    expect(flipProblems(ONE_LINE, after, "alpha")).not.toEqual([])
+  })
+
+  it("faults defaultOn: false", () => {
+    const after = ONE_LINE.replace('kind: "release" },', 'kind: "release", defaultOn: false },')
+    expect(flipProblems(ONE_LINE, after, "alpha")).not.toEqual([])
+  })
+
+  it("faults an unchanged registry", () => {
+    expect(flipProblems(ONE_LINE, ONE_LINE, "alpha")).toEqual([
+      '"alpha" is not set to defaultOn: true',
+    ])
+  })
+
+  it("faults a removed entry", () => {
+    expect(flipProblems(ONE_LINE, "export const FLAGS = []\n", "alpha")).toEqual([
+      'entry "alpha" is gone',
+    ])
+  })
+
+  it("faults defaultOn smuggled into a string instead of set as a property", () => {
+    const after = ONE_LINE.replace('owner: "a"', 'owner: "adefaultOn: true"')
+    expect(flipProblems(ONE_LINE, after, "alpha")).not.toEqual([])
+  })
+
+  it("faults whitespace edited inside a string", () => {
+    const before = ONE_LINE.replace('owner: "a"', 'owner: "a b"')
+    const after = before
+      .replace('owner: "a b"', 'owner: "ab"')
+      .replace('kind: "release" },', 'kind: "release", defaultOn: true },')
+    expect(flipProblems(before, after, "alpha")).not.toEqual([])
+  })
+
+  it("is empty for a flip when a JSDoc example of the entry precedes the array", () => {
+    const doc = '/** e.g. { name: "alpha", kind: "ops" } */\n'
+    const after = ONE_LINE.replace('kind: "release" },', 'kind: "release", defaultOn: true },')
+    expect(flipProblems(doc + ONE_LINE, doc + after, "alpha")).toEqual([])
+  })
+})
+
+describe("flipProblems trailing commas", () => {
+  const flip = (s: string) => s.replace('kind: "release" }', 'kind: "release", defaultOn: true }')
+
+  it("faults a comma-brace dropped inside a string", () => {
+    const before = ONE_LINE.replace('owner: "a"', 'owner: "team,}blue"')
+    const after = flip(before).replace('"team,}blue"', '"team}blue"')
+    expect(flipProblems(before, after, "alpha")).toContain('entry "alpha" changed beyond defaultOn')
+  })
+
+  it("faults a comma-brace dropped inside a comment", () => {
+    const before = ONE_LINE.replace('kind: "release" }', 'kind: "release", /* a,} */ }')
+    const after = flip(before).replace("/* a,} */", "/* a} */")
+    expect(flipProblems(before, after, "alpha")).toContain('entry "alpha" changed beyond defaultOn')
+  })
+
+  it("passes a real trailing comma added or removed", () => {
+    const comma = flip(ONE_LINE).replace("defaultOn: true }", "defaultOn: true, }")
+    expect(flipProblems(ONE_LINE, comma, "alpha")).toEqual([])
+    const before = ONE_LINE.replace('kind: "release" }', 'kind: "release", }')
+    expect(flipProblems(before, flip(ONE_LINE), "alpha")).toEqual([])
+  })
+})
+
+describe("requireFlag", () => {
+  afterEach(() => installContext(undefined))
+
+  const asFile = (text: string | undefined) =>
+    installContext({
+      read: (path: string) => (path === "reg.ts" ? text : undefined),
+      refuse: (message: string): never => {
+        throw new Error(message)
+      },
+    } as never)
+
+  it("accepts a flag that matches", () => {
+    asFile(ONE_LINE)
+    expect(() => requireFlag("rollout", "reg.ts", "alpha", false)).not.toThrow()
+    expect(() => requireFlag("cleanup", "reg.ts", "beta", true)).not.toThrow()
+  })
+
+  it("refuses an empty name", () => {
+    asFile(ONE_LINE)
+    expect(() => requireFlag("rollout", "reg.ts", "", false)).toThrow(
+      "gtd: rollout needs --var flag=<name>",
+    )
+  })
+
+  it("refuses an unknown flag, and a missing registry", () => {
+    asFile(ONE_LINE)
+    expect(() => requireFlag("cleanup", "reg.ts", "nope", true)).toThrow(
+      'gtd: cleanup: no flag "nope" in reg.ts',
+    )
+    asFile(undefined)
+    expect(() => requireFlag("rollout", "reg.ts", "alpha", false)).toThrow(
+      'gtd: rollout: no flag "alpha" in reg.ts',
+    )
+  })
+
+  it("refuses a non-release flag", () => {
+    asFile(ONE_LINE)
+    expect(() => requireFlag("rollout", "reg.ts", "gamma", false)).toThrow(
+      'gtd: rollout: flag "gamma" is ops, not release',
+    )
+  })
+
+  it("refuses the wrong default", () => {
+    asFile(ONE_LINE)
+    expect(() => requireFlag("rollout", "reg.ts", "beta", false)).toThrow(
+      'gtd: rollout: flag "beta" is already default-on',
+    )
+    expect(() => requireFlag("cleanup", "reg.ts", "alpha", true)).toThrow(
+      'gtd: cleanup: flag "alpha" is not default-on — roll it out first',
+    )
+  })
+})
+
+describe("flagReferences", () => {
+  it("reports path:line for the flag's env var in shipped sources", () => {
+    const files = [
+      { path: "src/a.ts", text: "x\nconst on = env.GTD_FLAG_ALPHA\n" },
+      { path: "src/web/b.tsx", text: "GTD_FLAG_ALPHA\n\nGTD_FLAG_ALPHA" },
+      { path: "src/c.ts", text: "nothing\n" },
+    ]
+    expect(flagReferences(files, "alpha")).toEqual([
+      "src/a.ts:2",
+      "src/web/b.tsx:1",
+      "src/web/b.tsx:3",
+    ])
+  })
+
+  it("ignores test, fixture and stories files and longer names", () => {
+    const text = "GTD_FLAG_ALPHA\n"
+    const files = [
+      { path: "src/a.test.ts", text },
+      { path: "src/a.fixture.ts", text },
+      { path: "src/a.stories.tsx", text },
+      { path: "src/b.ts", text: "GTD_FLAG_ALPHA_X\nXGTD_FLAG_ALPHA\n" },
+    ]
+    expect(flagReferences(files, "alpha")).toEqual([])
+  })
+
+  it("matches regex metacharacters in the name literally", () => {
+    const files = [
+      { path: "src/a.ts", text: "GTD_FLAG_AXB\nGTD_FLAG_A.B\n" },
+      { path: "src/b.ts", text: "GTD_FLAG_AAB\nGTD_FLAG_A+B\n" },
+    ]
+    expect(flagReferences(files, "a.b")).toEqual(["src/a.ts:2"])
+    expect(flagReferences(files, "a+b")).toEqual(["src/b.ts:2"])
+    expect(() => flagReferences(files, "a(b")).not.toThrow()
+    expect(flagReferences(files, "a(b")).toEqual([])
+  })
+})