@ossy/media-tasks 3.15.0 → 3.17.0

package/README.md

@@ -6,27 +6,32 @@ Tasks in this package are registered with `TaskService.RegisterTask()` at API st
 
 ## Tasks
 
-| Task id | Trigger | Description |
-|---------|---------|-------------|
-| `@ossy/media-tasks/tasks/resize-common-web` | `@ossy/platform/schema/file` `Created` (`content.ContentType: image/*`) | Generates common web thumbnail and gallery sizes using `sharp`, then patches `content.blurhash` / `content.width` / `content.height` |
-| `@ossy/media-tasks/tasks/visual-content-descriptors` | `@ossy/platform/schema/file` `Created` (`image/*`, `video/*`) | Uses GPT-4o to generate title, description, tags, and alt text |
+| Task id | Definition trigger (ceiling) | Description |
+|---------|------------------------------|-------------|
+| `@ossy/media-tasks/tasks/resize-common-web` | file `Created` + `image/*` | Common web sizes + BlurHash → storage keys under the source id |
+| `@ossy/media-tasks/tasks/extract-colors` | file `Created` + `image/*` | Dominant color + palette JSON → storage |
+| `@ossy/media-tasks/tasks/visual-content-descriptors` | file `Created` + `image/*` / `video/*` | OpenRouter vision → title/description/tags/alt JSON → storage. Input `model` (config or payload); default `openai/gpt-4o-mini`, overridable per trigger. |
+| `@ossy/media-tasks/tasks/run-prompt` | file `Created` + `text/*` / `image/*` / `application/json`, or `@ossy/resources/schema/markdown` `Created` | OpenRouter chat completion. Inputs `prompt` (required), `model` (default `openai/gpt-4o-mini`), optional `temperature`. File bytes or the Markdown document `body` are the context. |
 
-## Image placeholders (BlurHash)
+All four set **`configurable: true`**. Workspaces arm them on `/automation` with their own `triggers[]` (within the ceiling above) and optional placement folders. Until armed, they do not run.
 
-After derivatives upload, `resize-common-web` encodes a [BlurHash](https://blurha.sh/) string and natural pixel size onto the file resource via `@ossy/resources/actions/patch-content` (ADR 0008 `Patched` deep merge — does not replace `sizes`).
+## Task outputs
 
-Consumers (`Image` / `ImageCard`) prefer `content.blurhash` for an instant local placeholder, and still fall back to `sizes['loader-square-blurred-after']`. `width` / `height` set CSS `aspect-ratio` to reduce layout shift.
+1. **Artifact** — storage key `{resourceId}:task-{concept}-{outputName}`; read via `GET /r/:id/tasks/:concept/:name`
+2. **Placement** — `placeTaskArtifacts` creates a document **only when** `outputs[].prefix` or workspace `placementLocations` are set (no default folder)
 
-## Schemas
+| Task | Output | Placed schema |
+|------|--------|---------------|
+| extract-colors | `palette` | `@ossy/media-tasks/schema/extract-colors` |
+| resize-common-web | `sizes` (+ binary keys) | `@ossy/media-tasks/schema/resize-common-web` (JSON meta placed; binaries via URL) |
+| visual-content-descriptors | `descriptors` | `@ossy/media-tasks/schema/visual-content-descriptors` |
+| run-prompt | `completion` | `@ossy/platform/schema/text-completion` (freeform text/md — a platform schema, not feature-owned) |
 
-Task outcome schemas live in `src/*.schema.js` and are auto-discovered at build time:
+See [TaskOutput.md](../../docs/concepts/TaskOutput.md).
 
-| Schema | Id |
-|--------|----|
-| Resize Common Web | `@ossy/media-tasks/schema/resize-common-web` |
-| Visual Content Descriptors | `@ossy/media-tasks/schema/visual-content-descriptors` |
+## Image placeholders (BlurHash)
 
-These describe optional task-run documents; handlers are implemented in the matching `*.task.js` files.
+`resize-common-web` stores BlurHash + dimensions on the **`sizes`** JSON artifact. Consumers use `resizeImageMeta` / `resizeArtifactSrc` from `@ossy/resources` after media URL attach.
 
 ## Task contract
 
@@ -36,21 +41,35 @@ Each `*.task.js` file exports:
 export const metadata = {
   id: '@ossy/media-tasks/tasks/my-task',
   triggers: [{ type, event, match?, location? }],
+  inputs: [{ name: 'model', type: 'text', default: 'openai/gpt-4o-mini', sources: ['payload', 'config'] }],
+  outputs: [{ name, kind: 'location', schemaId, contentType }],
+  configurable: true,
 }
 
-export async function run ({ event, sdk }) { ... }
+export async function run ({ event, sdk, inputs }) { ... }
 ```
 
-- `metadata.id` — canonical task id (`@ossy/<package>/tasks/…`)
-- `triggers[].type` — resource schema id to watch (e.g. `@ossy/platform/schema/file`)
-- `triggers[].event` — lifecycle event name (`Created`, `Patched`, …)
-- `triggers[].match` — optional field matcher on `event.payload` (e.g. `{ 'content.ContentType': 'image/*' }`)
-- `event` — the raw eventstore `fullDocument` (`resourceId`, `type`, `event`, `payload`, …)
-- `sdk` — platform SDK instance (passed from API startup; `null` during local dev if unconfigured)
+`configurable: true` opts the task into Automation UI workspace triggers, input defaults, per-trigger overrides, and output placement. Omit it for system tasks. Definition `triggers` are the capability ceiling; workspaces author their own `triggers[]`. Each trigger’s `config` overrides instance `config` for that match only. `run` reads the resolved values from `inputs`.
+
+## Integrations
+
+| Id | Credentials | Used by |
+|----|-------------|---------|
+| `openrouter` | `OPENROUTER_API_KEY` (required); optional `OPENROUTER_SITE_URL`, `OPENROUTER_APP_TITLE`, `OPENROUTER_BASE_URL` | `visual-content-descriptors` and `run-prompt` via `integrations.get('openrouter')` |
+
+OpenRouter is OpenAI-compatible (`baseURL` `https://openrouter.ai/api/v1`). The VCD `model` input defaults to `openai/gpt-4o-mini`. A workspace can set another slug as the instance default, and a different slug on a single trigger (folder or MIME). An invoke payload still wins.
+
+`run-prompt` sends the resolved prompt as the user message. A matching file is appended as context (text/JSON excerpt, or an image data URL). A Markdown document (`@ossy/resources/schema/markdown`) sends `content.body` instead. The completion is stored at `{resourceId}:task-run-prompt-completion` and placed only when the workspace set a folder. **Run now** invokes `@ossy/media-tasks/actions/run-prompt` with the editor values; without a resource id the completion is returned on the task run and not stored.
+
+## Usage metering and a monthly token cap (ADR 0017)
+
+Both OpenRouter tasks read `response.usage` and return it as `result.usage = { model, promptTokens, completionTokens, totalTokens }`. `TaskRunService` forwards this onto `MeteringService.record()` automatically (any task returning `result.usage` in this shape gets metered — no per-task wiring needed).
+
+Before calling OpenRouter, each task calls `assertLlmUsageBudget()` (`@ossy/platform/metering`) — a **hard, fail-closed** monthly token cap **per workspace** (`LLM_WORKSPACE_MONTHLY_TOKEN_CAP` env var default `2_000_000`, overridable per workspace via `@ossy/workspaces/actions/set-llm-monthly-token-limit`). Once a workspace crosses its effective limit, further runs throw `{ status: 402, code: 'LLM_TOKEN_QUOTA_EXCEEDED' }` — no OpenRouter call made, no tokens spent. Named generically, not after OpenRouter specifically, so swapping the provider later needs no rename. See `docs/adr/0017-llm-usage-metering-and-quota.md`.
 
 ## Dependencies
 
-- **`sharp`** (peer) — image resizing + metadata in `resize-common-web`
+- **`sharp`** (peer) — image resizing + metadata
 - **`blurhash`** — encode compact placeholders after resize
-- **`openai`** (peer) — GPT-4o vision in `visual-content-descriptors`
-- **`@ossy/platform`** — `StorageClient.load` for reading uploaded file bytes (provided at runtime by the platform server)
+- **`openai`** (peer) — OpenAI SDK client pointed at OpenRouter
+- **`@ossy/platform`** — `StorageClient` for reading/writing file bytes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ossy/media-tasks",
-  "version": "3.15.0",
-  "description": "Changestream-triggered media processing tasks (image resize, AI descriptors)",
+  "version": "3.17.0",
+  "description": "Changestream-triggered media processing tasks (image resize, AI descriptors, prompts)",
   "type": "module",
   "main": "./src/index.js",
   "module": "./src/index.js",
@@ -17,7 +17,9 @@
   },
   "dependencies": {
     "@ossy/observability": "^3.0.9",
-    "@ossy/resources": "^3.15.0",
+    "@ossy/platform": "^3.17.0",
+    "@ossy/resources": "^3.17.0",
+    "@ossy/schema": "^3.17.0",
     "blurhash": "^2.0.5"
   },
   "peerDependencies": {
@@ -34,5 +36,5 @@
   ],
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
-  "gitHead": "23517232ddc4f2c64ca0062faa3cad84ceaa34a7"
+  "gitHead": "91ff7dffe9b0bddcb823daee67213d2008eb64e9"
 }

package/src/extract-colors.js

@@ -0,0 +1,71 @@
+/**
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ */
+function toHex (r, g, b) {
+  return `#${[r, g, b].map(c => c.toString(16).padStart(2, '0')).join('')}`
+}
+
+/** Expand a 4-bit channel (0–15) to 0–255. */
+function expandNibble (nibble) {
+  return nibble * 17
+}
+
+/**
+ * Extract a small palette from an image buffer via sharp (resize + 4-bit RGB buckets).
+ *
+ * @param {import('sharp')} sharp
+ * @param {Buffer} sourceBuffer
+ * @param {{ maxColors?: number, sampleSize?: number }} [options]
+ * @returns {Promise<{ dominant: string | null, colors: Array<{ hex: string, ratio: number }> }>}
+ */
+export async function extractColorsFromBuffer (sharp, sourceBuffer, options = {}) {
+  const maxColors = options.maxColors ?? 5
+  const sampleSize = options.sampleSize ?? 64
+
+  const { data, info } = await sharp(sourceBuffer)
+    .ensureAlpha()
+    .resize(sampleSize, sampleSize, { fit: 'inside' })
+    .raw()
+    .toBuffer({ resolveWithObject: true })
+
+  const channels = info.channels
+  /** @type {Map<number, number>} */
+  const buckets = new Map()
+  let visible = 0
+
+  for (let i = 0; i < data.length; i += channels) {
+    const a = channels === 4 ? data[i + 3] : 255
+    if (a < 128) continue
+    visible += 1
+    const r = data[i] >> 4
+    const g = data[i + 1] >> 4
+    const b = data[i + 2] >> 4
+    const key = (r << 8) | (g << 4) | b
+    buckets.set(key, (buckets.get(key) || 0) + 1)
+  }
+
+  if (visible === 0) {
+    return { dominant: null, colors: [] }
+  }
+
+  const ranked = [...buckets.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, maxColors)
+
+  const colors = ranked.map(([key, count]) => {
+    const r = expandNibble((key >> 8) & 0xf)
+    const g = expandNibble((key >> 4) & 0xf)
+    const b = expandNibble(key & 0xf)
+    return {
+      hex: toHex(r, g, b),
+      ratio: Math.round((count / visible) * 1000) / 1000,
+    }
+  })
+
+  return {
+    dominant: colors[0]?.hex ?? null,
+    colors,
+  }
+}

package/src/extract-colors.schema.js

@@ -0,0 +1,21 @@
+import { TASK_OUTPUT_PROVENANCE_FIELDS } from '@ossy/schema'
+
+export default {
+  name: 'Extract Colors',
+  id: '@ossy/media-tasks/schema/extract-colors',
+  categoryName: 'Media processing',
+  icon: 'color-picker',
+  fields: [
+    {
+      name: 'dominant',
+      type: 'text',
+      description: 'Dominant hex color',
+    },
+    {
+      name: 'colors',
+      type: 'textarea',
+      description: 'Palette entries as JSON ({ hex, ratio }[])',
+    },
+    ...TASK_OUTPUT_PROVENANCE_FIELDS,
+  ],
+}

package/src/extract-colors.spec.js

@@ -0,0 +1,44 @@
+import sharp from 'sharp'
+import { extractColorsFromBuffer } from './extract-colors.js'
+
+describe('extractColorsFromBuffer', () => {
+  it('returns the dominant color for a solid image', async () => {
+    const sourceBuffer = await sharp({
+      create: {
+        width: 40,
+        height: 40,
+        channels: 3,
+        background: { r: 20, g: 120, b: 200 },
+      },
+    })
+      .png()
+      .toBuffer()
+
+    const result = await extractColorsFromBuffer(sharp, sourceBuffer)
+
+    expect(result.dominant).toMatch(/^#[0-9a-f]{6}$/)
+    expect(result.colors.length).toBeGreaterThanOrEqual(1)
+    expect(result.colors[0].hex).toBe(result.dominant)
+    expect(result.colors[0].ratio).toBeGreaterThan(0.9)
+
+    // 20→17, 120→119, 200→204 after 4-bit quantization (*17)
+    expect(result.dominant).toBe('#1177cc')
+  })
+
+  it('ignores fully transparent pixels', async () => {
+    const sourceBuffer = await sharp({
+      create: {
+        width: 16,
+        height: 16,
+        channels: 4,
+        background: { r: 0, g: 0, b: 0, alpha: 0 },
+      },
+    })
+      .png()
+      .toBuffer()
+
+    const result = await extractColorsFromBuffer(sharp, sourceBuffer)
+    expect(result.dominant).toBeNull()
+    expect(result.colors).toEqual([])
+  })
+})

package/src/extract-colors.task.js

@@ -0,0 +1,79 @@
+import { createLogger } from '@ossy/observability'
+import { StorageClient } from '@ossy/platform'
+import { taskArtifactObjectKey } from '@ossy/platform/storage-keys'
+import { GetResource, placeTaskArtifacts } from '@ossy/resources'
+import { extractColorsFromBuffer } from './extract-colors.js'
+import { loadSourceBuffer } from './load-source-buffer.js'
+import { resolveConfiguredPlacements } from './resolve-configured-placement.js'
+
+const log = createLogger('media-tasks')
+
+const TASK_ID = '@ossy/media-tasks/tasks/extract-colors'
+const SCHEMA_ID = '@ossy/media-tasks/schema/extract-colors'
+const CONCEPT = 'extract-colors'
+const OUTPUT = {
+  name: 'palette',
+  kind: 'location',
+  schemaId: SCHEMA_ID,
+  contentType: 'application/json',
+  // prefix omitted — place only when workspace config supplies a location
+}
+
+export const metadata = {
+  id: TASK_ID,
+  triggers: [
+    {
+      type: '@ossy/platform/schema/file',
+      event: 'Created',
+      match: { 'content.ContentType': 'image/*' },
+    },
+  ],
+  outputs: [OUTPUT],
+  configurable: true,
+}
+
+export async function run ({ event, sdk }) {
+  const { default: sharp } = await import('sharp')
+  const resourceId = event.resourceId
+
+  log.info(`[media-tasks/tasks/extract-colors] starting for resource ${resourceId}`)
+
+  const resource = await sdk.invoke(GetResource, { resourceId })
+  const key = resource?.content?.Key
+  if (!key) {
+    throw new Error(`[media-tasks/tasks/extract-colors] missing storage key for ${resourceId}`)
+  }
+
+  const sourceBuffer = await loadSourceBuffer(key)
+  if (!sourceBuffer) {
+    throw new Error(`[media-tasks/tasks/extract-colors] missing file bytes for ${resourceId}`)
+  }
+
+  const palette = await extractColorsFromBuffer(sharp, sourceBuffer)
+  const objectKey = taskArtifactObjectKey(resourceId, CONCEPT, OUTPUT.name)
+  await StorageClient.save(objectKey, Buffer.from(JSON.stringify(palette), 'utf8'))
+  log.info(`[media-tasks/tasks/extract-colors] saved ${objectKey} dominant=${palette.dominant}`)
+
+  const placementLocations = await resolveConfiguredPlacements(sdk, TASK_ID, OUTPUT.name)
+  const placed = await placeTaskArtifacts({
+    sdk,
+    sourceResource: resource,
+    taskId: TASK_ID,
+    output: OUTPUT,
+    body: palette,
+    artifactKey: objectKey,
+    placementLocations,
+  })
+  if (placed.length) {
+    log.info(`[media-tasks/tasks/extract-colors] placed ${placed.length} resource(s): ${placed.map((r) => r.id).join(', ')}`)
+  } else {
+    log.info(`[media-tasks/tasks/extract-colors] artifact only (no placement location configured)`)
+  }
+  return {
+    output: OUTPUT.name,
+    key: objectKey,
+    placedResourceIds: placed.map((r) => r.id),
+    placedResourceId: placed[0]?.id ?? null,
+    dominant: palette.dominant,
+  }
+}

package/src/llm-usage.js

@@ -0,0 +1,21 @@
+/**
+ * OpenRouter (OpenAI-compatible) chat completions return token usage as
+ * `response.usage = { prompt_tokens, completion_tokens, total_tokens }`.
+ * Callers echo this back on their result as `usage` so it flows through
+ * `TaskRunService` → `MeteringService` generically (see ADR 0017).
+ *
+ * @param {{ usage?: { prompt_tokens?: number, completion_tokens?: number, total_tokens?: number }, model?: string } | null | undefined} response
+ * @param {string} fallbackModel Model slug requested, used when the response omits `model`.
+ * @returns {{ model: string, promptTokens: number | null, completionTokens: number | null, totalTokens: number | null }}
+ */
+export function usageFromResponse (response, fallbackModel) {
+  const model = typeof response?.model === 'string' && response.model ? response.model : fallbackModel
+  const usage = response?.usage
+  const promptTokens = typeof usage?.prompt_tokens === 'number' ? usage.prompt_tokens : null
+  const completionTokens = typeof usage?.completion_tokens === 'number' ? usage.completion_tokens : null
+  const totalTokens = typeof usage?.total_tokens === 'number'
+    ? usage.total_tokens
+    : (promptTokens != null || completionTokens != null ? (promptTokens ?? 0) + (completionTokens ?? 0) : null)
+
+  return { model, promptTokens, completionTokens, totalTokens }
+}

package/src/llm-usage.spec.js

@@ -0,0 +1,41 @@
+import { usageFromResponse } from './llm-usage.js'
+
+describe('usageFromResponse', () => {
+  it('reads prompt/completion/total tokens and the model that answered', () => {
+    expect(usageFromResponse({
+      model: 'openai/gpt-4o-mini-2024-07-18',
+      usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+    }, 'openai/gpt-4o-mini')).toEqual({
+      model: 'openai/gpt-4o-mini-2024-07-18',
+      promptTokens: 10,
+      completionTokens: 5,
+      totalTokens: 15,
+    })
+  })
+
+  it('derives totalTokens when the response omits it', () => {
+    expect(usageFromResponse({
+      usage: { prompt_tokens: 10, completion_tokens: 5 },
+    }, 'openai/gpt-4o-mini')).toEqual({
+      model: 'openai/gpt-4o-mini',
+      promptTokens: 10,
+      completionTokens: 5,
+      totalTokens: 15,
+    })
+  })
+
+  it('falls back to the requested model and nulls when usage is missing', () => {
+    expect(usageFromResponse({}, 'openai/gpt-4o-mini')).toEqual({
+      model: 'openai/gpt-4o-mini',
+      promptTokens: null,
+      completionTokens: null,
+      totalTokens: null,
+    })
+    expect(usageFromResponse(null, 'openai/gpt-4o-mini')).toEqual({
+      model: 'openai/gpt-4o-mini',
+      promptTokens: null,
+      completionTokens: null,
+      totalTokens: null,
+    })
+  })
+})

package/src/load-source-buffer.js

@@ -0,0 +1,17 @@
+import { StorageClient } from '@ossy/platform'
+
+/**
+ * Created fires before the client finishes PUT; wait briefly for blob bytes.
+ *
+ * @param {string} key
+ * @param {{ attempts?: number, delayMs?: number }} [options]
+ * @returns {Promise<Buffer | null>}
+ */
+export async function loadSourceBuffer (key, { attempts = 20, delayMs = 250 } = {}) {
+  for (let i = 0; i < attempts; i++) {
+    const { buffer, exists } = await StorageClient.load(key)
+    if (exists && buffer) return buffer
+    await new Promise(resolve => setTimeout(resolve, delayMs))
+  }
+  return null
+}

package/src/openrouter.integration.js

@@ -0,0 +1,30 @@
+import OpenAiSDK from 'openai'
+
+export const id = 'openrouter'
+
+export const credentials = ['OPENROUTER_API_KEY']
+
+const DEFAULT_BASE_URL = 'https://openrouter.ai/api/v1'
+const DEFAULT_SITE_URL = 'https://ossy.se'
+const DEFAULT_APP_TITLE = 'Ossy'
+
+/**
+ * Returns an OpenAI-compatible client pointed at OpenRouter.
+ * Tasks receive this via `integrations.get('openrouter')`.
+ *
+ * @param {{ env: NodeJS.ProcessEnv }} opts
+ * @returns {import('openai').OpenAI}
+ */
+export async function connect ({ env }) {
+  const siteUrl = env.OPENROUTER_SITE_URL || env.WEB_CLIENT_DOMAIN || DEFAULT_SITE_URL
+  const appTitle = env.OPENROUTER_APP_TITLE || DEFAULT_APP_TITLE
+
+  return new OpenAiSDK({
+    apiKey: env.OPENROUTER_API_KEY,
+    baseURL: env.OPENROUTER_BASE_URL || DEFAULT_BASE_URL,
+    defaultHeaders: {
+      'HTTP-Referer': siteUrl,
+      'X-OpenRouter-Title': appTitle,
+    },
+  })
+}

package/src/openrouter.integration.spec.js

@@ -0,0 +1,37 @@
+import { connect, credentials, id } from './openrouter.integration.js'
+
+describe('openrouter.integration', () => {
+  it('exports id and required credentials', () => {
+    expect(id).toBe('openrouter')
+    expect(credentials).toEqual(['OPENROUTER_API_KEY'])
+  })
+
+  it('connects an OpenAI-compatible client to OpenRouter', async () => {
+    const client = await connect({
+      env: {
+        OPENROUTER_API_KEY: 'test-key',
+        WEB_CLIENT_DOMAIN: 'https://example.test',
+        OPENROUTER_APP_TITLE: 'Ossy Test',
+      },
+    })
+
+    expect(client.apiKey).toBe('test-key')
+    expect(client.baseURL).toBe('https://openrouter.ai/api/v1')
+    expect(client._options.defaultHeaders['HTTP-Referer']).toBe('https://example.test')
+    expect(client._options.defaultHeaders['X-OpenRouter-Title']).toBe('Ossy Test')
+  })
+
+  it('allows overriding base URL and site attribution', async () => {
+    const client = await connect({
+      env: {
+        OPENROUTER_API_KEY: 'k',
+        OPENROUTER_BASE_URL: 'https://openrouter.example/v1',
+        OPENROUTER_SITE_URL: 'https://custom.site',
+      },
+    })
+
+    expect(client.baseURL).toBe('https://openrouter.example/v1')
+    expect(client._options.defaultHeaders['HTTP-Referer']).toBe('https://custom.site')
+    expect(client._options.defaultHeaders['X-OpenRouter-Title']).toBe('Ossy')
+  })
+})

package/src/resize-common-web.schema.js

@@ -1,20 +1,31 @@
+import { TASK_OUTPUT_PROVENANCE_FIELDS } from '@ossy/schema'
+
 export default {
   name: 'Resize Common Web',
   id: '@ossy/media-tasks/schema/resize-common-web',
   categoryName: 'Media processing',
-  icon: 'attribution',
+  icon: 'screen-shot',
   fields: [
     {
-      name: 'resourceId',
+      name: 'blurhash',
       type: 'text',
+      description: 'BlurHash placeholder string',
     },
     {
-      name: 'status',
-      type: 'text',
+      name: 'width',
+      type: 'number',
+      description: 'Natural image width',
+    },
+    {
+      name: 'height',
+      type: 'number',
+      description: 'Natural image height',
     },
     {
-      name: 'result',
+      name: 'artifacts',
       type: 'textarea',
+      description: 'Named derivative artifacts (thumbnail/gallery sizes)',
     },
+    ...TASK_OUTPUT_PROVENANCE_FIELDS,
   ],
 }

package/src/resize-common-web.task.js

@@ -1,10 +1,23 @@
 import { createLogger } from '@ossy/observability'
 import { StorageClient } from '@ossy/platform'
-import { GetResource, PatchResourceContent } from '@ossy/resources'
+import { taskArtifactObjectKey } from '@ossy/platform/storage-keys'
+import { GetResource, placeTaskArtifacts } from '@ossy/resources'
 import { encodeBlurhashFromBuffer } from './encode-blurhash.js'
+import { loadSourceBuffer } from './load-source-buffer.js'
+import { resolveConfiguredPlacements } from './resolve-configured-placement.js'
 
 const log = createLogger('media-tasks')
 
+const TASK_ID = '@ossy/media-tasks/tasks/resize-common-web'
+const SCHEMA_ID = '@ossy/media-tasks/schema/resize-common-web'
+const CONCEPT = 'resize-common-web'
+const OUTPUT = {
+  name: 'sizes',
+  kind: 'location',
+  schemaId: SCHEMA_ID,
+  contentType: 'application/json',
+}
+
 const Sizes = [
   { width: 24, height: 24, name: 'thumbnailSmall' },
   { width: 48, height: 48, name: 'thumbnailLarge' },
@@ -14,18 +27,8 @@ const Sizes = [
   { width: 4, height: undefined, name: 'loader-square-blurred-after' },
 ]
 
-/** Created fires before the client finishes PUT; wait briefly for blob bytes. */
-async function loadSourceBuffer (key, { attempts = 20, delayMs = 250 } = {}) {
-  for (let i = 0; i < attempts; i++) {
-    const { buffer, exists } = await StorageClient.load(key)
-    if (exists && buffer) return buffer
-    await new Promise(resolve => setTimeout(resolve, delayMs))
-  }
-  return null
-}
-
 export const metadata = {
-  id: '@ossy/media-tasks/tasks/resize-common-web',
+  id: TASK_ID,
   triggers: [
     {
       type: '@ossy/platform/schema/file',
@@ -33,6 +36,8 @@ export const metadata = {
       match: { 'content.ContentType': 'image/*' },
     },
   ],
+  outputs: [OUTPUT],
+  configurable: true,
 }
 
 export async function run ({ event, sdk }) {
@@ -52,31 +57,54 @@ export async function run ({ event, sdk }) {
     throw new Error(`[media-tasks/tasks/resize-common-web] missing file bytes for ${resourceId}`)
   }
 
+  const mime = resource.content?.ContentType ?? 'image/jpeg'
+  /** @type {Record<string, { key: string, contentType: string, width?: number, height?: number }>} */
+  const artifacts = {}
+
   log.info(`[media-tasks/tasks/resize-common-web] Resizing ${resourceId}`)
 
   for (const { width, height, name } of Sizes) {
-    const resizedBuffer = await sharp(sourceBuffer).resize(width, height).toBuffer()
-    const mime = resource.content?.ContentType ?? 'image/jpeg'
-    const file = new File([new Uint8Array(resizedBuffer)], name, { type: mime })
+    const resized = sharp(sourceBuffer).resize(width, height)
+    const { data, info } = await resized.toBuffer({ resolveWithObject: true })
+    const objectKey = taskArtifactObjectKey(resourceId, CONCEPT, name)
+
+    log.info(`[media-tasks/tasks/resize-common-web] Saving ${name} for ${resourceId}`)
+    await StorageClient.save(objectKey, data)
 
-    log.info(`[media-tasks/tasks/resize-common-web] Uploading ${name} for ${resourceId}`)
-    try {
-      await sdk.resources.uploadNamedVersion({ id: resourceId, name, file })
-    } catch (error) {
-      log.error(`[media-tasks/tasks/resize-common-web] Error uploading ${name} for ${resourceId}`, undefined, error)
-      throw error
+    artifacts[name] = {
+      key: objectKey,
+      contentType: mime,
+      ...(info.width != null ? { width: info.width } : {}),
+      ...(info.height != null ? { height: info.height } : {}),
     }
   }
 
-  try {
-    const { blurhash, width, height } = await encodeBlurhashFromBuffer(sharp, sourceBuffer)
-    log.info(`[media-tasks/tasks/resize-common-web] Patching blurhash for ${resourceId}`)
-    await sdk.invoke(PatchResourceContent, {
-      id: resourceId,
-      content: { blurhash, width, height },
-    })
-  } catch (error) {
-    log.error(`[media-tasks/tasks/resize-common-web] Error encoding blurhash for ${resourceId}`, undefined, error)
-    throw error
+  const { blurhash, width, height } = await encodeBlurhashFromBuffer(sharp, sourceBuffer)
+  const sizesBody = { artifacts, blurhash, width, height }
+  const sizesKey = taskArtifactObjectKey(resourceId, CONCEPT, OUTPUT.name)
+  await StorageClient.save(sizesKey, Buffer.from(JSON.stringify(sizesBody), 'utf8'))
+  log.info(`[media-tasks/tasks/resize-common-web] saved ${sizesKey}`)
+
+  const placementLocations = await resolveConfiguredPlacements(sdk, TASK_ID, OUTPUT.name)
+  const placed = await placeTaskArtifacts({
+    sdk,
+    sourceResource: resource,
+    taskId: TASK_ID,
+    output: OUTPUT,
+    body: sizesBody,
+    artifactKey: sizesKey,
+    placementLocations,
+  })
+  if (placed.length) {
+    log.info(`[media-tasks/tasks/resize-common-web] placed ${placed.length} resource(s)`)
+  } else {
+    log.info(`[media-tasks/tasks/resize-common-web] artifact only (no placement location configured)`)
+  }
+  return {
+    output: OUTPUT.name,
+    key: sizesKey,
+    placedResourceIds: placed.map((r) => r.id),
+    placedResourceId: placed[0]?.id ?? null,
+    artifactCount: Object.keys(artifacts).length,
   }
 }