@crombolo/transfer 0.0.0-stage → 0.10.0

package/src/export.ts

@@ -0,0 +1,316 @@
+/**
+ * Database → bundle.
+ *
+ * Reads the selected subtrees through `DocumentRepository`'s own public reads,
+ * so the values a bundle carries are exactly the values the site would serve or
+ * show, converters and culture handling included.
+ *
+ * The snapshot rule: a published node carries its **published** values, because
+ * a bundle should hold what the source site actually serves; an unpublished one
+ * carries its draft and says so. `--drafts` takes the current draft throughout,
+ * for the case where the point is to move work in progress.
+ */
+import type { DocumentAggregate, DocumentValue } from '@crombolo/core'
+import { ObjectTypes } from '@crombolo/core'
+import {
+  ComponentRepository,
+  type ContentKind,
+  currentSchemaState,
+  type Db,
+  DocumentRepository,
+  type NodeRow,
+} from '@crombolo/data'
+import {
+  BUNDLE_FORMAT_VERSION,
+  type BundleBlob,
+  type BundleDependency,
+  type BundleKind,
+  type BundleNode,
+  type BundleSnapshot,
+  type BundleValue,
+  type ContentSet,
+} from './model.ts'
+import { referenceCandidates } from './references.ts'
+
+/** The kinds a bundle carries, and the repository kind each reads through. */
+const KINDS: Record<BundleKind, { objectType: string; contentKind: ContentKind }> = {
+  document: { objectType: ObjectTypes.Document, contentKind: 'document' },
+  media: { objectType: ObjectTypes.Media, contentKind: 'media' },
+  element: { objectType: ObjectTypes.Element, contentKind: 'element' },
+  blueprint: { objectType: ObjectTypes.DocumentBlueprint, contentKind: 'blueprint' },
+}
+
+/** Editors that hold a file rather than a reference to one. */
+const FILE_EDITORS = new Set(['Umbraco.ImageCropper', 'Umbraco.UploadField'])
+
+export interface ExportOptions {
+  /** Resolved subtree roots, by key. */
+  roots: readonly NodeRow[]
+  /** What was typed, kept for the manifest. */
+  asGiven: readonly string[]
+  descendants: boolean
+  snapshot: BundleSnapshot
+  /** Include blueprints reached from the selection. */
+  blueprints: boolean
+  /**
+   * Whether the bundle is to carry its media files.
+   *
+   * The bytes are not read here: where media lives is the store's business, and
+   * this package knows nothing about it. The keys come back in `blobKeys`
+   * whatever this says, and the writer decides `included` from the bytes the
+   * caller actually managed to read.
+   */
+  withBlobs: boolean
+  siteName: string
+  nodeId: string
+}
+
+export interface ExportResult {
+  set: ContentSet
+  /** Media store keys the caller should copy when `withBlobs` is set. */
+  blobKeys: string[]
+}
+
+/**
+ * `/media/ab12cd34/photo.jpg` → `ab12cd34/photo.jpg`, the store's own key.
+ * `MediaFiles.key` does this in `@crombolo/server`, but the prefix is a URL
+ * convention rather than store behaviour and this package must not depend on
+ * the composition root to read it.
+ */
+function storeKey(src: unknown): string | undefined {
+  const text = typeof src === 'string' ? src : undefined
+  if (!text) return undefined
+  const match = /^\/?media\/(.+)$/.exec(text)
+  return match?.[1]
+}
+
+function blobKeysOf(values: readonly DocumentValue[]): string[] {
+  const found: string[] = []
+  for (const value of values) {
+    if (!value.editorAlias || !FILE_EDITORS.has(value.editorAlias)) continue
+    const raw = value.value
+    const src =
+      typeof raw === 'string'
+        ? raw
+        : typeof raw === 'object' && raw !== null
+          ? (raw as Record<string, unknown>).src
+          : undefined
+    const key = storeKey(src)
+    if (key) found.push(key)
+  }
+  return found
+}
+
+function toBundleValue(value: DocumentValue, references: readonly string[]): BundleValue {
+  return {
+    property: value.alias,
+    culture: value.culture,
+    segment: value.segment,
+    editor: value.editorAlias ?? '',
+    value: value.value,
+    references: references.length > 0 ? [...references] : undefined,
+  }
+}
+
+function toBundleNode(
+  node: NodeRow,
+  kind: BundleKind,
+  aggregate: DocumentAggregate,
+  parentKeyByNodeId: (id: number) => string | null,
+  componentAlias: string | null,
+  candidates: Map<DocumentValue, string[]>,
+): BundleNode {
+  return {
+    key: node.key,
+    kind,
+    contentType: { key: aggregate.contentTypeKey, alias: aggregate.contentTypeAlias },
+    parent: parentKeyByNodeId(node.parentId),
+    sortOrder: node.sortOrder,
+    template: componentAlias,
+    variants: aggregate.variants.map((v) => ({
+      culture: v.culture,
+      segment: v.segment,
+      name: v.name,
+      published: v.state === 'Published' || v.state === 'PublishedPendingChanges',
+    })),
+    values: aggregate.values.map((v) => toBundleValue(v, candidates.get(v) ?? [])),
+  }
+}
+
+/** Every node of the selection, roots first and parents before children. */
+async function selected(
+  db: Db,
+  options: ExportOptions,
+): Promise<Array<{ node: NodeRow; kind: BundleKind }>> {
+  const byKind = new Map<string, BundleKind>(
+    Object.entries(KINDS).map(([kind, v]) => [v.objectType, kind as BundleKind]),
+  )
+  const wanted: string[] = [ObjectTypes.Document, ObjectTypes.Media, ObjectTypes.Element]
+  if (options.blueprints) wanted.push(ObjectTypes.DocumentBlueprint)
+
+  const found = new Map<number, { node: NodeRow; kind: BundleKind }>()
+  const nodes = new DocumentRepository(db).nodes
+  for (const root of options.roots) {
+    const kind = byKind.get(root.objectType ?? '')
+    if (kind) found.set(root.id, { node: root, kind })
+    if (!options.descendants) continue
+    for (const descendant of await nodes.descendants(root, wanted)) {
+      const k = byKind.get(descendant.objectType ?? '')
+      if (k) found.set(descendant.id, { node: descendant, kind: k })
+    }
+  }
+  return [...found.values()].sort((a, b) => a.node.level - b.node.level || a.node.id - b.node.id)
+}
+
+export async function exportBundle(db: Db, options: ExportOptions): Promise<ExportResult> {
+  const chosen = await selected(db, options)
+
+  /**
+   * Read at the state the database is at, not at the repository's default.
+   *
+   * A repository constructed without a `nodeState` runs at the install
+   * baseline, and reads are as-of that state — so `visibleStateIdFor` finds no
+   * state row at or below it and every value is filtered out. The export then
+   * succeeds and carries nothing, which is the worst possible failure. A tool
+   * reading content is not a node asserting a deployment; it takes the
+   * database's own state.
+   */
+  const state = await currentSchemaState(db)
+  const nodeState = { version: state.version, revision: state.revision }
+
+  const repos = new Map<ContentKind, DocumentRepository>()
+  const repoFor = (kind: BundleKind): DocumentRepository => {
+    const contentKind = KINDS[kind].contentKind
+    const existing = repos.get(contentKind)
+    if (existing) return existing
+    const repo = new DocumentRepository(db, { kind: contentKind, nodeState })
+    repos.set(contentKind, repo)
+    return repo
+  }
+
+  const nodes = new DocumentRepository(db).nodes
+  const templateRepo = new ComponentRepository(db)
+  const keyOfNodeId = new Map<number, string>()
+  for (const { node } of chosen) keyOfNodeId.set(node.id, node.key)
+
+  const bundleNodes: BundleNode[] = []
+  const blobs: BundleBlob[] = []
+  const referenced = new Set<string>()
+  const contentTypes = new Map<string, string>()
+  const templates = new Set<string>()
+  const languages = new Set<string>()
+  const counts: Partial<Record<BundleKind, number>> = {}
+
+  for (const { node, kind } of chosen) {
+    const repo = repoFor(kind)
+    // Media is never published, so there is no published snapshot to prefer.
+    const published =
+      options.snapshot === 'published' && kind !== 'media'
+        ? await repo.byKeyPublished(node.key)
+        : undefined
+    const aggregate = published ?? (await repo.byKey(node.key))
+    if (!aggregate) continue
+
+    const candidates = new Map<DocumentValue, string[]>()
+    for (const value of aggregate.values) {
+      const keys = referenceCandidates(value.value)
+      if (keys.length > 0) candidates.set(value, keys)
+      for (const key of keys) referenced.add(key)
+    }
+
+    // The parent travels as a key only when it is in the bundle; otherwise it is
+    // an expected dependency, which the destination must already have. The
+    // system containers — the tree root and the recycle bins — have real `node`
+    // rows with keys of their own, and a node sitting under one has no parent as
+    // far as a bundle is concerned.
+    const parentKey =
+      node.parentId <= 0
+        ? null
+        : (keyOfNodeId.get(node.parentId) ?? (await nodes.byId(node.parentId))?.key ?? null)
+    // A template's definition is its file, so the alias travels and the key does
+    // not: the same view has a different key in every environment.
+    const componentAlias = aggregate.componentKey
+      ? ((await templateRepo.byKey(aggregate.componentKey))?.alias ?? null)
+      : null
+
+    bundleNodes.push(
+      toBundleNode(node, kind, aggregate, () => parentKey, componentAlias, candidates),
+    )
+    counts[kind] = (counts[kind] ?? 0) + 1
+    contentTypes.set(aggregate.contentTypeAlias, aggregate.contentTypeKey)
+    if (componentAlias) templates.add(componentAlias)
+    for (const variant of aggregate.variants) if (variant.culture) languages.add(variant.culture)
+    if (kind === 'media')
+      for (const key of blobKeysOf(aggregate.values))
+        blobs.push({ key, node: node.key, etag: null, size: null, included: false })
+  }
+
+  const carried = new Set(bundleNodes.map((n) => n.key))
+
+  // Anything referenced or parented that the bundle does not carry must already
+  // exist at the destination. A candidate that resolves to no node here was
+  // never a reference — an undashed uuid is indistinguishable from any other 32
+  // hex characters — so it is dropped rather than demanded.
+  const outside = [...referenced].filter((key) => !carried.has(key))
+  const expected: BundleDependency[] = []
+  for (const row of await nodes.byKeys(outside)) {
+    expected.push({
+      key: row.key,
+      objectType: row.objectType ?? '',
+      name: row.text ?? '',
+      why: 'referenced by a value in this bundle',
+    })
+  }
+  for (const node of bundleNodes) {
+    if (!node.parent || carried.has(node.parent)) continue
+    if (expected.some((e) => e.key === node.parent)) continue
+    const row = await nodes.byKey(node.parent)
+    if (row)
+      expected.push({
+        key: row.key,
+        objectType: row.objectType ?? '',
+        name: row.text ?? '',
+        why: `parent of ${node.variants[0]?.name ?? node.key}`,
+      })
+  }
+
+  return {
+    set: {
+      manifest: {
+        formatVersion: BUNDLE_FORMAT_VERSION,
+        id: crypto.randomUUID(),
+        createdAt: new Date().toISOString(),
+        createdBy: options.nodeId,
+        // writeBundle recomputes this over the node files it emits.
+        integrity: '',
+        snapshot: options.snapshot,
+        provenance: {
+          siteName: options.siteName,
+          schemaVersion: state.version,
+          schemaRevision: state.revision,
+          schemaHash: state.hash,
+        },
+        selector: {
+          roots: options.roots.map((r) => r.key),
+          descendants: options.descendants,
+          asGiven: [...options.asGiven],
+        },
+        counts,
+        dependencies: {
+          carried: [...carried],
+          expected,
+          schema: {
+            contentTypes: [...contentTypes].map(([alias, key]) => ({ key, alias })),
+            components: [...templates],
+            languages: [...languages],
+          },
+        },
+        blobs,
+      },
+      nodes: bundleNodes,
+    },
+    // Every key, carried or not: a caller that is not carrying them still has
+    // to be able to say how many files this bundle expects to find elsewhere.
+    blobKeys: [...new Set(blobs.map((b) => b.key))],
+  }
+}

package/src/import.ts

@@ -0,0 +1,331 @@
+/**
+ * Bundle → database.
+ *
+ * Four properties the implementation is shaped around, in order of how badly
+ * getting them wrong would hurt:
+ *
+ * 1. **Everything goes through `DocumentRepository`.** `is_current` is
+ *    maintained on insert by the repository's own write path; a writer reaching
+ *    into `property_value` would corrupt the flag that every hot-path read
+ *    depends on.
+ * 2. **Values are an overlay, never a replacement.** `#appendValues` treats what
+ *    it is given as the complete set and *clears* anything current that is
+ *    absent from it. So the values handed to `update` are this node's current
+ *    values with the bundle's laid over them — otherwise an import silently
+ *    empties every property the bundle does not carry.
+ * 3. **One lock and one transaction for the whole run**, so a failure anywhere
+ *    leaves nothing behind. `inTreeLock` on the repositories is what makes that
+ *    possible without deadlocking on re-entry.
+ * 4. **Two passes.** Every node is created before any value is written, so a
+ *    page that links to a page that links back needs no ordering cleverness.
+ *
+ * Sibling order needs no handling of its own: nodes are created in the bundle's
+ * own order within a parent, and `nodes.create` appends, so new siblings land
+ * in bundle order after whatever was already there. The bundle's `sortOrder` is
+ * therefore not replayed — appending is the only sane answer when the
+ * destination already has children, and it is what this gives.
+ *
+ * Idempotence falls out of (2): the repository appends only what differs, so
+ * importing the same bundle twice writes no values the second time.
+ */
+import type { DocumentValue } from '@crombolo/core'
+import {
+  appendCacheInstruction,
+  ComponentRepository,
+  type ContentKind,
+  ContentTypeRepository,
+  currentSchemaState,
+  type Db,
+  DocumentRepository,
+  Locks,
+  PublishBlockedError,
+  type TransferAction,
+  TransferRunRepository,
+} from '@crombolo/data'
+import { type CheckOptions, checkBundle, type NodePlan, type TransferCheck } from './check.ts'
+import type { BundleKind, BundleNode, ContentSet } from './model.ts'
+
+const CONTENT_KIND: Record<BundleKind, ContentKind> = {
+  document: 'document',
+  media: 'media',
+  element: 'element',
+  blueprint: 'blueprint',
+}
+
+export interface ImportOptions extends CheckOptions {
+  /** Publish what the bundle says was live at the source. Without it, everything lands as a draft. */
+  publish?: boolean
+  /** Recorded as who applied the run. */
+  nodeId?: string
+  /** A human label for the run listing. */
+  label?: string | undefined
+  /** The npm package the bundle arrived in, recorded on the run. */
+  package?: { name: string; version: string } | undefined
+}
+
+export interface ImportResult {
+  /** Undefined when the run was refused: nothing was written. */
+  runId: string | undefined
+  check: TransferCheck
+  applied: NodePlan[]
+  /** Nodes published, by key. */
+  published: string[]
+  /** Set when `--publish` was asked for and a business rule refused one. */
+  publishFailures: Array<{ key: string; reason: string }>
+}
+
+/** Parents before children, for whatever the bundle carries. */
+function inTreeOrder(nodes: readonly BundleNode[]): BundleNode[] {
+  const byKey = new Map(nodes.map((n) => [n.key, n]))
+  const done = new Set<string>()
+  const ordered: BundleNode[] = []
+  const visit = (node: BundleNode, seen: Set<string>): void => {
+    if (done.has(node.key) || seen.has(node.key)) return
+    seen.add(node.key)
+    const parent = node.parent ? byKey.get(node.parent) : undefined
+    if (parent) visit(parent, seen)
+    if (done.has(node.key)) return
+    done.add(node.key)
+    ordered.push(node)
+  }
+  for (const node of nodes) visit(node, new Set())
+  return ordered
+}
+
+/** The bundle's values laid over what is here, keyed as the database keys them. */
+function overlay(current: readonly DocumentValue[], node: BundleNode): DocumentValue[] {
+  const at = (v: { culture: string | null; segment: string | null }, alias: string) =>
+    `${alias}|${v.culture ?? ''}|${v.segment ?? ''}`
+  const merged = new Map<string, DocumentValue>()
+  for (const value of current) merged.set(at(value, value.alias), value)
+  for (const value of node.values)
+    merged.set(at(value, value.property), {
+      alias: value.property,
+      culture: value.culture,
+      segment: value.segment,
+      value: value.value,
+    })
+  return [...merged.values()]
+}
+
+export async function importBundle(
+  db: Db,
+  set: ContentSet,
+  options: ImportOptions = {},
+): Promise<ImportResult> {
+  return db.locks.withLock(Locks.ContentTree, async () =>
+    db.transaction(async (tx) => {
+      // The check runs again inside the lock, over the tree as it is now, so a
+      // decision made against a stale read cannot slip through. Same discipline
+      // `upgrade` uses before it cuts over.
+      const check = await checkBundle(tx, set, options)
+      if (check.outstanding.length > 0)
+        return {
+          runId: undefined,
+          check,
+          applied: [],
+          published: [],
+          publishFailures: [],
+        }
+
+      const state = await currentSchemaState(tx)
+      const nodeState = { version: state.version, revision: state.revision }
+      const runs = new TransferRunRepository(tx)
+      const types = new ContentTypeRepository(tx)
+      // A media node's type is a different object type, invisible to a
+      // repository reading content types. See the same pairing in `check.ts`.
+      const mediaTypes = new ContentTypeRepository(tx, { kind: 'media' })
+      const typesFor = (kind: BundleKind): ContentTypeRepository =>
+        CONTENT_KIND[kind] === 'media' ? mediaTypes : types
+      const templates = new ComponentRepository(tx)
+
+      const repos = new Map<ContentKind, DocumentRepository>()
+      const repoFor = (kind: BundleKind): DocumentRepository => {
+        const contentKind = CONTENT_KIND[kind]
+        const existing = repos.get(contentKind)
+        if (existing) return existing
+        const repo = new DocumentRepository(tx, {
+          kind: contentKind,
+          nodeState,
+          nodeId: options.nodeId,
+          // One lock for the run, taken above.
+          inTreeLock: true,
+        })
+        repos.set(contentKind, repo)
+        return repo
+      }
+
+      const runId = crypto.randomUUID()
+      await runs.start({
+        id: runId,
+        bundleId: set.manifest.id,
+        bundleLabel: options.label ?? null,
+        packageName: options.package?.name ?? null,
+        packageVersion: options.package?.version ?? null,
+        direction: 'import',
+        revertsRunId: null,
+        schemaStateId: state.id,
+        startedAt: new Date(),
+        appliedBy: options.nodeId ?? null,
+        nodeCount: 0,
+      })
+
+      const planByKey = new Map(check.plan.map((p) => [p.key, p]))
+      const ordered = inTreeOrder(set.nodes).filter(
+        (node) => planByKey.get(node.key)?.action !== 'skip',
+      )
+
+      // What each node was before this run, read before anything is written:
+      // the two numbers a revert needs to put the site back.
+      const before = new Map<string, { head: number | undefined; published: number | undefined }>()
+      for (const node of ordered) {
+        const markers = await repoFor(node.kind).eventMarkers(node.key)
+        if (markers) before.set(node.key, markers)
+      }
+
+      // Pass one: every node exists, with its name, and nothing else. A value
+      // written in pass two can therefore refer to any node in the bundle.
+      const created = new Set<string>()
+      /** Where each created node actually landed, which the sort below groups by. */
+      const landedUnder = new Map<string, string | null>()
+      for (const node of ordered) {
+        if (before.has(node.key)) continue
+        const repo = repoFor(node.kind)
+        const forKind = typesFor(node.kind)
+        const type =
+          (node.contentType.key ? await forKind.byKey(node.contentType.key) : undefined) ??
+          (await forKind.byAlias(node.contentType.alias))
+        // The check raises `missing-content-type` for this and refuses the run,
+        // so reaching here means the two disagree. Throwing rolls the whole
+        // transaction back; skipping the node would import part of the bundle
+        // and report success.
+        if (!type)
+          throw new Error(
+            `No content type "${node.contentType.alias}" for "${node.key}", which the check should have refused.`,
+          )
+        const parentKey =
+          node.parent && !created.has(node.parent) && !before.has(node.parent)
+            ? (options.under?.key ?? null)
+            : (node.parent ?? options.under?.key ?? null)
+        await repo.create({
+          key: node.key,
+          contentTypeKey: type.key,
+          componentKey: node.template
+            ? ((await templates.byAlias(node.template))?.key ?? null)
+            : null,
+          parentKey,
+          values: [],
+          variants: node.variants.map((v) => ({
+            culture: v.culture,
+            segment: v.segment,
+            name: v.name,
+          })),
+        })
+        created.add(node.key)
+        landedUnder.set(node.key, parentKey)
+      }
+
+      // The order a bundle's nodes sit in among their siblings travels with it.
+      // Without this they keep the order the run happened to create them in,
+      // which is a hash order, not an editor's — a site's navigation arrives
+      // shuffled. Only the nodes this run created are placed, and only into the
+      // slots they already occupy, so siblings that were here keep theirs.
+      const newByParent = new Map<string | null, BundleNode[]>()
+      for (const node of ordered) {
+        if (!created.has(node.key) || node.kind !== 'document') continue
+        const parent = landedUnder.get(node.key) ?? null
+        const group = newByParent.get(parent)
+        if (group) group.push(node)
+        else newByParent.set(parent, [node])
+      }
+      for (const [parent, group] of newByParent) {
+        if (group.length < 2) continue
+        const documents = repoFor('document')
+        const rows = await documents.nodes.byKeys(group.map((n) => n.key))
+        const slots = rows.map((row) => row.sortOrder).sort((a, b) => a - b)
+        const wanted = [...group].sort((a, b) => a.sortOrder - b.sortOrder)
+        await documents.sort(
+          parent,
+          wanted.flatMap((node, index) => {
+            const sortOrder = slots[index]
+            return sortOrder === undefined ? [] : [{ key: node.key, sortOrder }]
+          }),
+        )
+      }
+
+      // Pass two: the values, overlaid onto whatever is here.
+      const applied: NodePlan[] = []
+      for (const node of ordered) {
+        const plan = planByKey.get(node.key)
+        if (plan?.resolution === 'keep-local') {
+          applied.push(plan)
+          continue
+        }
+        const repo = repoFor(node.kind)
+        const current = await repo.byKey(node.key)
+        if (!current) continue
+        await repo.update({
+          key: node.key,
+          contentTypeKey: current.contentTypeKey,
+          componentKey: node.template
+            ? ((await templates.byAlias(node.template))?.key ?? current.componentKey)
+            : current.componentKey,
+          parentKey: current.parentKey,
+          values: overlay(current.values, node),
+          variants: node.variants.map((v) => ({
+            culture: v.culture,
+            segment: v.segment,
+            name: v.name,
+          })),
+        })
+        if (plan) applied.push(plan)
+      }
+
+      // Publishing is last, and parents first: an unpublished ancestor makes a
+      // published descendant unreachable, so the repository refuses it.
+      const published: string[] = []
+      const publishFailures: Array<{ key: string; reason: string }> = []
+      if (options.publish) {
+        for (const node of ordered) {
+          const live = node.variants.filter((v) => v.published)
+          if (live.length === 0 || node.kind === 'media') continue
+          const cultures = live.map((v) => v.culture).filter((c): c is string => c !== null)
+          try {
+            await repoFor(node.kind).publish(node.key, cultures.length > 0 ? cultures : null)
+            published.push(node.key)
+          } catch (error) {
+            if (!(error instanceof PublishBlockedError)) throw error
+            publishFailures.push({ key: node.key, reason: error.message })
+          }
+        }
+      }
+
+      for (const node of ordered) {
+        const markers = await repoFor(node.kind).eventMarkers(node.key)
+        const was = before.get(node.key)
+        const action: TransferAction = !was
+          ? 'create'
+          : (planByKey.get(node.key)?.action ?? 'unchanged')
+        await runs.record({
+          runId,
+          nodeKey: node.key,
+          kind: node.kind,
+          action,
+          beforeEventId: was?.head ?? null,
+          beforePublishedEventId: was?.published ?? null,
+          eventId: markers?.head ?? null,
+        })
+      }
+      await runs.finish(runId, ordered.length)
+
+      // Other nodes drop their published cache; this one already has.
+      await appendCacheInstruction(tx, {
+        kind: 'content',
+        payload: { bundle: set.manifest.id },
+        by: options.nodeId,
+      })
+
+      return { runId, check, applied, published, publishFailures }
+    }),
+  )
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './check.ts'
+export * from './export.ts'
+export * from './import.ts'
+export * from './load.ts'
+export * from './model.ts'
+export * from './package.ts'
+export * from './references.ts'
+export * from './resolutions.ts'
+export * from './revert.ts'
+export * from './write.ts'