@defrex/autobuild 0.12.0 → 0.13.0

package/packages/core/src/ports/tickets/migration.ts

@@ -0,0 +1,336 @@
+import { validateTicketAssetInput } from '../../store/ticket-assets'
+import { mkdir, readdir, readFile, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises'
+import { dirname, join, resolve } from 'node:path'
+import { z } from 'zod'
+import type { Ticket, TicketSource, TicketAssetStore } from '../types'
+import { FileTicketSource } from './file'
+import { parseTicketFile, serializeTicketFile } from './file-codec'
+import { validateFileTicketId } from './requested-id'
+import { normalizeStateName } from './states'
+import { encodePortableAsset, decodePortableAsset, type PortableAsset } from './portable-assets'
+
+const MANIFEST = '.ab-migration.json'
+export const IMPORT_MAP = '.ab-import-map.json'
+const manifestSchema = z.strictObject({
+  version: z.literal(1),
+  identity: z.string().min(1),
+  source: z.string(),
+  keys: z.record(z.string(), z.string().min(1)),
+  states: z.record(z.string(), z.string()),
+})
+type Manifest = z.infer<typeof manifestSchema>
+async function atomicJson(path: string, value: unknown) {
+  const temp = `${path}.${crypto.randomUUID()}.tmp`
+  await writeFile(temp, `${JSON.stringify(value, null, 2)}\n`)
+  await rename(temp, path)
+}
+async function inventory(source: TicketSource): Promise<Ticket[]> {
+  const listing = await source.listReady({})
+  if (listing.diagnostics.length)
+    throw new Error(`incomplete ticket scan:\n${listing.diagnostics.join('\n')}`)
+  const ids = new Set<string>()
+  const tickets: Ticket[] = []
+  for (const ticket of listing.tickets) {
+    if (ids.has(ticket.ref.id)) throw new Error(`duplicate ticket id: ${ticket.ref.id}`)
+    ids.add(ticket.ref.id)
+    const detail = await source.get(ticket.ref.id)
+    if (!detail) throw new Error(`ticket disappeared: ${ticket.ref.id}`)
+    if (!detail.state) throw new Error(`ticket has no state: ${ticket.ref.id}`)
+    tickets.push(detail)
+  }
+  return tickets
+}
+function uniqueStateMap(names: string[], map: (name: string) => string): Record<string, string> {
+  const result: Record<string, string> = Object.create(null)
+  const groups = new Map<string, string[]>()
+  for (const name of new Set(names)) {
+    const target = map(name)
+    result[name] = target
+    groups.set(target, [...(groups.get(target) ?? []), name])
+  }
+  const collisions = [...groups].filter(([, originals]) => originals.length > 1)
+  if (collisions.length)
+    throw new Error(
+      `state collisions: ${collisions.map(([target, originals]) => `${originals.join(', ')} → ${target}`).join('; ')}`,
+    )
+  return result
+}
+async function currentAssets(
+  store: TicketAssetStore | undefined,
+  repo: string,
+  id: string,
+): Promise<PortableAsset[]> {
+  if (!store) return []
+  const result: PortableAsset[] = []
+  for (const summary of await store.listTicketAssets(repo, id)) {
+    const asset = await store.getTicketAsset(repo, id, summary.kind, summary.name, summary.revision)
+    if (!asset) throw new Error(`asset disappeared: ${id} ${summary.kind}/${summary.name}`)
+    result.push(encodePortableAsset({ ...asset.meta, entries: asset.entries }))
+  }
+  return result
+}
+export interface MigrationOptions {
+  source: TicketSource
+  dir: string
+  repo: string
+  assets?: TicketAssetStore
+  print?: (line: string) => void
+}
+/** Publish a complete portable tracker only after every source read succeeds. */
+export async function exportTickets(opts: MigrationOptions): Promise<void> {
+  const destination = resolve(opts.dir)
+  try {
+    if ((await readdir(destination)).length)
+      throw new Error(`export destination is not empty: ${destination}`)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
+  }
+  const tickets = await inventory(opts.source)
+  const names = [
+    ...tickets.map((ticket) => ticket.state!),
+    ...((await opts.source.listStates?.()) ?? []).map((state) => state.name),
+  ]
+  const states = uniqueStateMap(names, normalizeStateName)
+  const identity = crypto.randomUUID()
+  const manifest: Manifest = {
+    version: 1,
+    identity,
+    source: `${opts.source.name}:${opts.repo}`,
+    keys: Object.create(null),
+    states,
+  }
+  const records = []
+  for (const ticket of tickets) {
+    validateFileTicketId(ticket.ref.id)
+    const key = ticket.creationKey ?? `migration:${identity}:${ticket.ref.id}`
+    manifest.keys[ticket.ref.id] = key
+    records.push({
+      state: states[ticket.state!]!,
+      id: ticket.ref.id,
+      raw: serializeTicketFile(
+        {
+          id: ticket.ref.id,
+          title: ticket.title,
+          labels: ticket.labels,
+          blockedBy: ticket.blockedBy,
+          idempotencyKey: key,
+          ...(ticket.comments !== undefined ? { comments: ticket.comments } : {}),
+          attachments: await currentAssets(
+            opts.assets ?? opts.source.assets,
+            opts.repo,
+            ticket.ref.id,
+          ),
+        },
+        ticket.body,
+      ),
+    })
+  }
+  await mkdir(dirname(destination), { recursive: true })
+  const staging = `${destination}.${identity}.tmp`
+  await mkdir(staging)
+  try {
+    for (const state of Object.values(states))
+      await mkdir(join(staging, state), { recursive: true })
+    for (const record of records)
+      await writeFile(join(staging, record.state, `${record.id}.md`), record.raw, { flag: 'wx' })
+    await atomicJson(join(staging, MANIFEST), manifest)
+    // Recheck immediately before publication; never remove a populated destination.
+    try {
+      await rmdir(destination)
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
+    }
+    await rename(staging, destination)
+  } finally {
+    await rm(staging, { recursive: true, force: true })
+  }
+  opts.print?.(`exported ${tickets.length} tickets to ${destination}`)
+}
+function matchState(name: string, existing: string[]): string | undefined {
+  if (existing.includes(name)) return name
+  const matches = existing.filter((value) => value.toLowerCase() === name.toLowerCase())
+  if (matches.length > 1) throw new Error(`ambiguous target state ${name}: ${matches.join(', ')}`)
+  return matches[0]
+}
+/** Resume through creation keys, never through content similarity or mapping files. */
+export async function importTickets(opts: MigrationOptions): Promise<void> {
+  const policy = opts.source.requestedIds
+  if (!policy || !opts.source.listStates || !opts.source.addState)
+    throw new Error(`ticket source ${opts.source.name} does not support import`)
+  const dir = resolve(opts.dir)
+  const input = new FileTicketSource({ dir })
+  const tickets = await inventory(input)
+  const bundles = new Map<string, PortableAsset[]>()
+  for (const ticket of tickets) {
+    const path = join(dir, ticket.state!, `${ticket.ref.id}.md`)
+    bundles.set(
+      ticket.ref.id,
+      parseTicketFile(path, await readFile(path, 'utf8')).front.attachments ?? [],
+    )
+  }
+  let manifest: Manifest
+  try {
+    manifest = manifestSchema.parse(JSON.parse(await readFile(join(dir, MANIFEST), 'utf8')))
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
+    manifest = {
+      version: 1,
+      identity: crypto.randomUUID(),
+      source: 'file',
+      keys: Object.create(null),
+      states: {},
+    }
+  }
+  const sourceIds = new Set(tickets.map((ticket) => ticket.ref.id))
+  const keys = new Set<string>()
+  for (const ticket of tickets) {
+    for (const blocker of ticket.blockedBy ?? [])
+      if (!sourceIds.has(blocker) || blocker === ticket.ref.id)
+        throw new Error(`invalid blocker ${ticket.ref.id} → ${blocker}`)
+    const key =
+      ticket.creationKey ??
+      manifest.keys[ticket.ref.id] ??
+      `migration:${manifest.identity}:${ticket.ref.id}`
+    if (keys.has(key)) throw new Error(`duplicate creation key: ${key}`)
+    keys.add(key)
+    manifest.keys[ticket.ref.id] = key
+  }
+  const target = await inventory(opts.source)
+  const byKey = new Map<string, Ticket>()
+  for (const ticket of target)
+    if (ticket.creationKey) {
+      if (byKey.has(ticket.creationKey))
+        throw new Error(`ambiguous target creation key: ${ticket.creationKey}`)
+      byKey.set(ticket.creationKey, ticket)
+    }
+  const existingStates = (await opts.source.listStates()).map((state) => state.name)
+  // Only actual input directories participate; virtual lifecycle defaults are harmless empty states.
+  const inputStates: string[] = []
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    if (
+      !entry.name.startsWith('.') &&
+      (entry.isDirectory() ||
+        (entry.isSymbolicLink() && (await stat(join(dir, entry.name))).isDirectory()))
+    )
+      inputStates.push(entry.name)
+  }
+  const states = uniqueStateMap(
+    inputStates,
+    (name) =>
+      matchState(name, existingStates) ??
+      matchState(normalizeStateName(name), existingStates) ??
+      normalizeStateName(name),
+  )
+  const planned = new Map<string, string>()
+  const occupied = target.map((ticket) => ticket.ref.id)
+  const clashes: string[] = []
+  for (const ticket of tickets) {
+    const adopted = byKey.get(manifest.keys[ticket.ref.id]!)
+    if (adopted) {
+      planned.set(ticket.ref.id, adopted.ref.id)
+      continue
+    }
+    const kept = policy.preserve(ticket.ref.id)
+    if (kept !== undefined) {
+      if (occupied.includes(kept)) clashes.push(`${ticket.ref.id} → ${kept}`)
+      planned.set(ticket.ref.id, kept)
+      occupied.push(kept)
+    }
+  }
+  if (clashes.length)
+    throw new Error(`ticket id clashes (no target changes):\n${clashes.join('\n')}`)
+  for (const ticket of tickets)
+    if (!planned.has(ticket.ref.id)) {
+      const id = policy.allocate(occupied)
+      planned.set(ticket.ref.id, id)
+      occupied.push(id)
+    }
+  const assets = opts.assets ?? opts.source.assets
+  if ([...bundles.values()].some((value) => value.length) && !assets)
+    throw new Error('target has no attachment capability')
+  if (assets && [...bundles.values()].some((value) => value.length)) {
+    const limits = await assets.ticketAssetLimits(opts.repo)
+    for (const values of bundles.values())
+      for (const bundle of values) validateTicketAssetInput(decodePortableAsset(bundle), limits)
+  }
+  for (const ticket of tickets) {
+    const adopted = byKey.get(manifest.keys[ticket.ref.id]!)
+    if ((ticket.comments?.length ?? 0) > 0 && adopted && adopted.comments === undefined)
+      throw new Error(`target cannot read comment history: ${adopted.ref.id}`)
+  }
+  // Persist identities before the first target write, including for ordinary layouts.
+  await atomicJson(join(dir, MANIFEST), manifest)
+  const mapping: Record<string, string> = Object.create(null)
+  const mappingPath = join(dir, IMPORT_MAP)
+  const saveMap = () =>
+    atomicJson(mappingPath, { version: 1, identity: manifest.identity, states, tickets: mapping })
+  await saveMap()
+  try {
+    for (const state of new Set(Object.values(states)))
+      if (!existingStates.includes(state)) {
+        try {
+          await opts.source.addState(state)
+        } catch (error) {
+          const discovered = matchState(
+            state,
+            (await opts.source.listStates()).map((item) => item.name),
+          )
+          if (!discovered) throw error
+          for (const original of Object.keys(states))
+            if (states[original] === state) states[original] = discovered
+          await saveMap()
+        }
+      }
+    for (const [from, to] of Object.entries(states)) opts.print?.(`state ${from} → ${to}`)
+    for (const ticket of tickets) {
+      const key = manifest.keys[ticket.ref.id]!
+      const result =
+        byKey.get(key) ??
+        (await opts.source.create(
+          { title: ticket.title, body: ticket.body, labels: ticket.labels },
+          {
+            state: states[ticket.state!]!,
+            idempotencyKey: key,
+            requestedId: planned.get(ticket.ref.id)!,
+          },
+        ))
+      mapping[ticket.ref.id] = result.ref.id
+      await saveMap()
+      opts.print?.(`${ticket.ref.id} → ${result.ref.id}`)
+    }
+    for (const ticket of tickets) {
+      const id = mapping[ticket.ref.id]!
+      for (const blocker of ticket.blockedBy ?? [])
+        await opts.source.addBlocker(id, mapping[blocker]!)
+      const fresh = await opts.source.get(id)
+      if (!fresh) throw new Error(`target disappeared: ${id}`)
+      if ((ticket.comments?.length ?? 0) && fresh.comments === undefined)
+        throw new Error(`target cannot read comment history: ${id}`)
+      const bodies = new Set(fresh.comments?.map((comment) => comment.body))
+      for (const comment of ticket.comments ?? [])
+        if (!bodies.has(comment.body)) {
+          await opts.source.comment(id, comment.body)
+          bodies.add(comment.body)
+        }
+      for (const bundle of bundles.get(ticket.ref.id) ?? []) {
+        const current = await assets!.getTicketAsset(opts.repo, id, bundle.kind, bundle.name)
+        const canonical = (asset: PortableAsset) =>
+          JSON.stringify({
+            ...asset,
+            entries: [...asset.entries].sort((a, b) => a.path.localeCompare(b.path)),
+          })
+        if (
+          !current ||
+          canonical(encodePortableAsset({ ...current.meta, entries: current.entries })) !==
+            canonical(bundle)
+        )
+          await assets!.putTicketAsset(opts.repo, id, decodePortableAsset(bundle))
+      }
+    }
+    opts.print?.(`mapping: ${mappingPath}`)
+  } catch (error) {
+    throw new Error(
+      `${error instanceof Error ? error.message : error}\nImport progress retained in ${mappingPath}; rerun import to finish.`,
+    )
+  }
+}

package/packages/core/src/ports/tickets/operations.ts

@@ -1,3 +1,8 @@
+import {
+  mutateTicketIfRevision,
+  TicketRevisionConflict,
+  TicketRevisionUnsupported,
+} from './revision'
 import type { Config } from '../../config/schema'
 import { readyCriteria } from '../../processes/dispatcher'
 import type { Ticket, TicketDraft, TicketSource, TicketUpdate } from '../types'
@@ -91,6 +96,8 @@ export async function createTicket(
       ? await source.create(draft)
       : await source.create(draft, { state: input.state })
   } catch (error) {
+    if (error instanceof TicketRevisionConflict || error instanceof TicketRevisionUnsupported)
+      throw error
     throw new TicketOperationError(
       'refusal',
       error instanceof Error ? error.message : String(error),
@@ -103,10 +110,15 @@ export async function updateTicket(
   id: string,
   patch: TicketUpdate,
   readAfter = true,
+  expectedRevision?: string,
 ): Promise<Ticket | null> {
   try {
-    await source.update(id, patch)
+    if (expectedRevision !== undefined)
+      await mutateTicketIfRevision(source, id, expectedRevision, { kind: 'update', patch })
+    else await source.update(id, patch)
   } catch (error) {
+    if (error instanceof TicketRevisionConflict || error instanceof TicketRevisionUnsupported)
+      throw error
     throw new TicketOperationError(
       'refusal',
       error instanceof Error ? error.message : String(error),
@@ -115,11 +127,20 @@ export async function updateTicket(
   return readAfter ? requirePostMutationTicket(source, id, 'the update') : null
 }
 
-export async function moveTicket(source: TicketSource, id: string, state: string): Promise<Ticket> {
+export async function moveTicket(
+  source: TicketSource,
+  id: string,
+  state: string,
+  expectedRevision?: string,
+): Promise<Ticket> {
   await requireTicket(source, id)
   try {
-    await source.transition(id, state)
+    if (expectedRevision !== undefined)
+      await mutateTicketIfRevision(source, id, expectedRevision, { kind: 'transition', state })
+    else await source.transition(id, state)
   } catch (error) {
+    if (error instanceof TicketRevisionConflict || error instanceof TicketRevisionUnsupported)
+      throw error
     throw new TicketOperationError(
       'refusal',
       error instanceof Error ? error.message : String(error),
@@ -133,6 +154,7 @@ export async function changeBlockers(
   id: string,
   blockerIds: string[],
   operation: 'block' | 'unblock',
+  expectedRevision?: string,
 ): Promise<Ticket> {
   await requireTicket(source, id)
   const ids = await knownBlockers(source, blockerIds, '')
@@ -143,11 +165,20 @@ export async function changeBlockers(
     )
   }
   try {
-    for (const blockerId of ids) {
-      if (operation === 'block') await source.addBlocker(id, blockerId)
-      else await source.removeBlocker(id, blockerId)
-    }
+    if (expectedRevision !== undefined)
+      await mutateTicketIfRevision(source, id, expectedRevision, {
+        kind: 'blockers',
+        operation,
+        ids,
+      })
+    else
+      for (const blockerId of ids) {
+        if (operation === 'block') await source.addBlocker(id, blockerId)
+        else await source.removeBlocker(id, blockerId)
+      }
   } catch (error) {
+    if (error instanceof TicketRevisionConflict || error instanceof TicketRevisionUnsupported)
+      throw error
     throw new TicketOperationError(
       'refusal',
       error instanceof Error ? error.message : String(error),

package/packages/core/src/ports/tickets/portable-assets.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod'
+import { validateTicketAssetInput, type TicketAssetInput } from '../../store/ticket-assets'
+
+export const portableAssetSchema = z
+  .strictObject({
+    kind: z.string(),
+    name: z.string(),
+    layout: z.enum(['file', 'tree']),
+    entries: z.array(
+      z.discriminatedUnion('type', [
+        z.strictObject({ type: z.literal('dir'), path: z.string() }),
+        z.strictObject({
+          type: z.literal('file'),
+          path: z.string(),
+          base64: z
+            .string()
+            .regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+        }),
+      ]),
+    ),
+  })
+  .superRefine((value, ctx) => {
+    try {
+      validateTicketAssetInput(decodePortableAsset(value))
+    } catch (error) {
+      ctx.addIssue({ code: 'custom', message: String(error) })
+    }
+  })
+export type PortableAsset = z.infer<typeof portableAssetSchema>
+export function decodePortableAsset(value: PortableAsset): TicketAssetInput {
+  return {
+    kind: value.kind,
+    name: value.name,
+    layout: value.layout,
+    entries: value.entries.map((entry) =>
+      entry.type === 'dir'
+        ? entry
+        : { type: 'file', path: entry.path, content: Buffer.from(entry.base64, 'base64') },
+    ),
+  }
+}
+export function encodePortableAsset(input: TicketAssetInput): PortableAsset {
+  validateTicketAssetInput(input)
+  return {
+    kind: input.kind,
+    name: input.name,
+    layout: input.layout,
+    entries: input.entries.map((entry) =>
+      entry.type === 'dir'
+        ? entry
+        : { type: 'file', path: entry.path, base64: Buffer.from(entry.content).toString('base64') },
+    ),
+  }
+}

package/packages/core/src/ports/tickets/remote-protocol.ts

@@ -1,6 +1,11 @@
 import { z } from 'zod'
 import { ticketRefSchema } from '../../ontology'
 
+/** Explicit opt-in: released clients through 0.12 use strict decoders without revisions.
+ * Source checkouts can share their release version, so version alone is insufficient. */
+export const TICKET_REVISIONS_HEADER = 'x-autobuild-ticket-revisions'
+export const TICKET_REVISIONS_CAPABILITY = '1'
+
 /** Repository-owned policy sent with every hosted ticket operation. */
 export const hostedTicketContextSchema = z.strictObject({
   teamKey: z.string().min(1),
@@ -10,8 +15,19 @@ export const hostedTicketContextSchema = z.strictObject({
 })
 export type HostedTicketContext = z.infer<typeof hostedTicketContextSchema>
 
+export const TICKET_COMMENTS_HEADER = 'x-autobuild-ticket-comments'
+export const TICKET_COMMENTS_CAPABILITY = '1'
+
+export const ticketCommentWireSchema = z.strictObject({
+  body: z.string(),
+  createdAt: z.string(),
+  author: z.string().optional(),
+})
+
 export const ticketWireSchema = z.strictObject({
+  revision: z.string().min(1),
   ref: ticketRefSchema,
+  comments: z.array(ticketCommentWireSchema).optional(),
   creationKey: z.string().optional(),
   title: z.string(),
   body: z.string(),
@@ -47,6 +63,7 @@ const draftSchema = z.strictObject({
   blockedBy: z.array(z.string()).optional(),
 })
 const createOptionsSchema = z.strictObject({
+  requestedId: z.string().min(1).optional(),
   state: z.string().optional(),
   idempotencyKey: z.string().optional(),
 })
@@ -62,8 +79,27 @@ function envelope<T extends z.ZodType>(input: T) {
   return z.strictObject({ context: hostedTicketContextSchema, input })
 }
 
+const mutationSchema = z.discriminatedUnion('kind', [
+  z.strictObject({ kind: z.literal('update'), patch: updateSchema }),
+  z.strictObject({ kind: z.literal('transition'), state: z.string().min(1) }),
+  z.strictObject({
+    kind: z.literal('blockers'),
+    operation: z.enum(['block', 'unblock']),
+    ids: z.array(z.string().min(1)),
+  }),
+])
+
 export const hostedTicketRequestSchemas = {
+  'mutate-if-revision': envelope(
+    z.strictObject({
+      id: z.string().min(1),
+      expectedRevision: z.string().refine((v) => v.trim().length > 0),
+      mutation: mutationSchema,
+    }),
+  ),
   'list-ready': envelope(criteriaSchema),
+  states: envelope(z.strictObject({})),
+  'add-state': envelope(z.strictObject({ name: z.string(), about: z.string().optional() })),
   get: envelope(idSchema),
   claim: envelope(idSchema),
   comment: envelope(z.strictObject({ id: z.string().min(1), body: z.string() })),
@@ -81,3 +117,62 @@ export type HostedTicketOperation = keyof typeof hostedTicketRequestSchemas
 export const HOSTED_TICKET_OPERATIONS = Object.keys(
   hostedTicketRequestSchemas,
 ) as HostedTicketOperation[]
+
+/** Project policy is separate from CRUD context and cannot be supplied by delegates. */
+export const hostedTicketPolicySchema = z.strictObject({
+  version: z.literal(1),
+  tickets: z.strictObject({
+    source: z.literal('hosted'),
+    teamKey: z.string().min(1),
+    readyState: z
+      .string()
+      .min(1)
+      .refine((value) => value.trim().length > 0, 'state must be nonblank'),
+    triageState: z
+      .string()
+      .min(1)
+      .refine((value) => value.trim().length > 0, 'state must be nonblank'),
+    claimedState: z
+      .string()
+      .min(1)
+      .refine((value) => value.trim().length > 0, 'state must be nonblank'),
+    doneState: z
+      .string()
+      .min(1)
+      .refine((value) => value.trim().length > 0, 'state must be nonblank'),
+    createState: z
+      .string()
+      .min(1)
+      .refine((value) => value.trim().length > 0, 'state must be nonblank'),
+    proposalState: z
+      .string()
+      .min(1)
+      .refine((value) => value.trim().length > 0, 'state must be nonblank'),
+    readyLabels: z.array(z.string().min(1)).optional(),
+  }),
+})
+export type HostedTicketPolicy = z.infer<typeof hostedTicketPolicySchema>
+
+export const ticketGrantSchema = z.strictObject({
+  id: z.string().min(1),
+  repo: z.string().min(1),
+  execution: z.string().min(1),
+  kind: z.enum(['runner', 'phase']),
+  parent: z.string().nullable(),
+  expiresAt: z.string().datetime(),
+})
+export const ticketGrantResponseSchema = z.strictObject({
+  token: z.string().startsWith('abt_'),
+  grant: ticketGrantSchema,
+})
+
+export const ticketStateWireSchema = z.strictObject({
+  name: z.string(),
+  tickets: z.number().int().nonnegative(),
+  about: z.string().optional(),
+})
+export const ticketStatesWireSchema = z.array(ticketStateWireSchema)
+export const ticketStateCreateWireSchema = z.strictObject({
+  state: ticketStateWireSchema,
+  created: z.boolean(),
+})