n8n-nodes-blurwerk 0.1.0

package/README.md

@@ -0,0 +1,74 @@
+# n8n-nodes-blurwerk
+
+An [n8n](https://n8n.io) node for [blurwerk](https://blurwerk.de/?ref=n8n):
+anonymize video inside a workflow. Every face in every frame is mosaiced,
+voices can be disguised or muted, and location metadata is removed. You get the
+same file back in the same format. Processing happens on blurwerk's own
+hardware in Germany; the video is never sent to a third-party AI service.
+
+## Install
+
+In n8n: **Settings → Community Nodes → Install**, and enter
+`n8n-nodes-blurwerk`.
+
+## Credentials
+
+blurwerk sells prepaid credit in whole units of €5. Buy it once at
+[blurwerk.de/credit](https://blurwerk.de/credit?ref=n8n). The page shows an API
+token (`bw_…`) **once**. Paste it into a new **blurwerk API** credential.
+
+## Operations
+
+| Operation | What it does |
+|---|---|
+| **Anonymize Video** | Takes a video from a binary field and prices it from its own header, read locally (nothing is uploaded to get a price). Then it pays with credit, uploads the file and, by default, waits and outputs the anonymized video as binary data. |
+| **Get Result** | Returns the state of an order and, once it is done, the video. Use it after an **Anonymize Video** run that did not wait. |
+| **Get Balance** | Returns the remaining credit. |
+| **Report Problem** | Reports that a delivered result is not usable. It is refunded, and the result is deleted. |
+
+**Anonymize Video** requires two declarations, both mandatory: that work may
+start at once (§ 356(4) BGB, which ends the 14-day withdrawal right), and that
+the result will be checked before it is published.
+
+**Options:**
+- **Audio:** keep, disguise the voice, or mute.
+- **Sensitivity:** how sure the detectors must be before a face is covered.
+- **Mosaic size**
+- **E-mail:** an address to send the download link to.
+- **Language**
+
+**File Details** are only needed if the node can't read the file's header
+(MP4, MOV, MKV, WebM, AVI, TS/M2TS, MPEG-PS and FLV all work). blurwerk
+measures the file again when it arrives. If it turns out cheaper, you're
+charged the lower price; if it turns out dearer, the order is refused and
+refunded.
+
+## Timing
+
+Processing takes about twice the video's length at 1080p and about eleven
+times at 4K, because every frame is checked at full resolution. For long
+videos, or on n8n Cloud plans with short execution limits, turn off **Wait for
+Result**. Then fetch the video later with **Get Result**, for example on a
+schedule.
+
+## Privacy
+
+- The filename never leaves your n8n instance; only the extension is sent.
+- blurwerk deletes the uploaded copy as soon as the job finishes, and deletes
+  the result when its download link expires.
+- See [blurwerk.de/datenschutz](https://blurwerk.de/datenschutz).
+
+## Development
+
+```sh
+npm install --ignore-scripts   # n8n-workflow's native optional deps are not needed
+npm test                       # builds, then runs a whole order against a fake server
+```
+
+The header parser in `nodes/Blurwerk/vendor/` is copied from the website's
+`web/static` at build time. The repository's test suite fails if the two
+differ.
+
+## License
+
+MIT

package/dist/credentials/BlurwerkApi.credentials.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlurwerkApi = void 0;
+class BlurwerkApi {
+    name = 'blurwerkApi';
+    displayName = 'blurwerk API';
+    documentationUrl = 'https://blurwerk.de/docs';
+    properties = [
+        {
+            displayName: 'API Token',
+            name: 'token',
+            type: 'string',
+            typeOptions: { password: true },
+            default: '',
+            placeholder: 'bw_...',
+            description: 'A prepaid credit token. Buy credit once at https://blurwerk.de/credit — the token is shown once, store it here.',
+        },
+        {
+            displayName: 'Base URL',
+            name: 'baseUrl',
+            type: 'string',
+            default: 'https://blurwerk.de',
+        },
+    ];
+    authenticate = {
+        type: 'generic',
+        properties: {
+            headers: { Authorization: '=Bearer {{$credentials.token}}' },
+        },
+    };
+    test = {
+        request: {
+            baseURL: '={{$credentials.baseUrl}}',
+            url: '/api/credits/balance',
+        },
+    };
+}
+exports.BlurwerkApi = BlurwerkApi;

package/dist/nodes/Blurwerk/Blurwerk.node.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blurwerk = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const client_1 = require("./client");
+const properties_1 = require("./properties");
+// n8n's own request helper, so the instance's proxy and TLS settings apply.
+function httpFor(ctx) {
+    return async (req) => {
+        const options = {
+            method: req.method,
+            url: req.url,
+            headers: req.headers,
+            returnFullResponse: true,
+            ignoreHttpStatusErrors: true,
+            json: !req.raw && !req.binary,
+        };
+        if (req.json !== undefined)
+            options.body = req.json;
+        if (req.raw)
+            options.body = req.raw;
+        if (req.binary)
+            options.encoding = 'arraybuffer';
+        const res = (await ctx.helpers.httpRequest(options));
+        return { status: res.statusCode, headers: res.headers || {}, body: res.body };
+    };
+}
+// A finished job becomes an item carrying the video, when there is one.
+async function finish(ctx, api, jobId, s, i, sourceName) {
+    const job = (s.job || {});
+    const json = {
+        jobId, state: job.state, expiresIn: s.expires_in, expired: !!s.expired,
+        voice: job.voice, error: job.error,
+    };
+    const item = { json, pairedItem: i };
+    const url = s.download_url;
+    if (url && ctx.getNodeParameter('download', i, true)) {
+        const video = await api.download(url);
+        const ext = client_1.BlurwerkClient.extension(new URL(url).pathname);
+        const name = `${(sourceName || jobId).replace(/\.[^.]+$/, '')}_anonymized${ext}`;
+        item.binary = { data: await ctx.helpers.prepareBinaryData(video, name) };
+    }
+    else if (url) {
+        json.downloadUrl = url;
+    }
+    return item;
+}
+async function anonymize(ctx, api, i) {
+    const prop = ctx.getNodeParameter('binaryPropertyName', i);
+    const binary = ctx.helpers.assertBinaryData(i, prop);
+    const file = await ctx.helpers.getBinaryDataBuffer(i, prop);
+    const opts = ctx.getNodeParameter('options', i, {});
+    const details = ctx.getNodeParameter('fileDetails', i, {});
+    const options = {
+        audio: opts.audio || 'keep',
+        faces: true,
+        sensitivity: opts.sensitivity || 'medium',
+        coverage: opts.coverage || 'medium',
+        lang: opts.lang || 'en',
+    };
+    const placed = await api.order({
+        file,
+        fileName: binary.fileName || 'video.mp4',
+        options,
+        consentWithdrawal: ctx.getNodeParameter('consentWithdrawal', i),
+        consentCheck: ctx.getNodeParameter('consentCheck', i),
+        email: opts.email || '',
+        stated: {
+            duration: details.duration,
+            width: details.width,
+            height: details.height,
+            fps: details.fps,
+        },
+    });
+    const wait = ctx.getNodeParameter('wait', i);
+    if (!wait)
+        return { json: { ...placed, state: 'uploaded' }, pairedItem: i };
+    const done = await api.waitFor(placed.jobId, ctx.getNodeParameter('maxWait', i) * 60_000, ctx.getNodeParameter('pollEvery', i) * 1000);
+    if (!done) {
+        return { json: { ...placed, state: 'processing',
+                note: 'Still processing. Fetch it later with the "Get Result" operation.' }, pairedItem: i };
+    }
+    const item = await finish(ctx, api, placed.jobId, done, i, binary.fileName);
+    item.json = { ...placed, ...item.json };
+    return item;
+}
+class Blurwerk {
+    description = {
+        displayName: 'blurwerk',
+        name: 'blurwerk',
+        icon: 'file:blurwerk.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["operation"]}}',
+        description: 'Anonymize video: every face mosaiced, voices disguised or muted, metadata removed. Processed in Germany.',
+        defaults: { name: 'blurwerk' },
+        inputs: ['main'],
+        outputs: ['main'],
+        usableAsTool: true,
+        credentials: [{ name: 'blurwerkApi', required: true }],
+        properties: properties_1.properties,
+    };
+    async execute() {
+        const items = this.getInputData();
+        const out = [];
+        const creds = await this.getCredentials('blurwerkApi');
+        const api = new client_1.BlurwerkClient(httpFor(this), String(creds.baseUrl || 'https://blurwerk.de'), String(creds.token || ''));
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const op = this.getNodeParameter('operation', i);
+                if (op === 'balance') {
+                    out.push({ json: await api.balance(), pairedItem: i });
+                }
+                else if (op === 'status') {
+                    const jobId = this.getNodeParameter('jobId', i);
+                    out.push(await finish(this, api, jobId, await api.status(jobId), i));
+                }
+                else if (op === 'problem') {
+                    out.push({
+                        json: await api.reportProblem(this.getNodeParameter('jobId', i), this.getNodeParameter('reason', i), this.getNodeParameter('email', i)),
+                        pairedItem: i,
+                    });
+                }
+                else {
+                    out.push(await anonymize(this, api, i));
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    out.push({ json: { error: error.message }, pairedItem: i });
+                    continue;
+                }
+                if (error instanceof client_1.BlurwerkError && error.status) {
+                    throw new n8n_workflow_1.NodeApiError(this.getNode(), { message: error.message }, { httpCode: String(error.status), itemIndex: i });
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+            }
+        }
+        return [out];
+    }
+}
+exports.Blurwerk = Blurwerk;

package/dist/nodes/Blurwerk/Blurwerk.node.json

@@ -0,0 +1,11 @@
+{
+  "node": "n8n-nodes-blurwerk.blurwerk",
+  "nodeVersion": "1.0",
+  "codexVersion": "1.0",
+  "categories": ["Data & Storage", "Utility"],
+  "resources": {
+    "credentialDocumentation": [{ "url": "https://blurwerk.de/docs" }],
+    "primaryDocumentation": [{ "url": "https://blurwerk.de/docs" }]
+  },
+  "alias": ["blur", "face", "anonymize", "gdpr", "dsgvo", "pixelate", "redact", "privacy", "video"]
+}

package/dist/nodes/Blurwerk/blurwerk.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32">
+<rect width="32" height="32" rx="8" fill="#12705a"/>
+<rect x="8" y="8" width="7" height="7" fill="#5fe0b4"/><rect x="17" y="8" width="7" height="7" fill="#2fa07c"/>
+<rect x="8" y="17" width="7" height="7" fill="#2fa07c"/><rect x="17" y="17" width="7" height="7" fill="#8ff0cf"/>
+</svg>

package/dist/nodes/Blurwerk/client.js

@@ -0,0 +1,175 @@
+"use strict";
+/* The whole order, as the API guide (docs/API.md) describes it, with no n8n in it.
+
+   Kept apart from the node so it can be driven against a fake server in a
+   plain `node --test` run: the node only turns n8n parameters into a call
+   here and the result back into items.
+
+   The file is priced from its own header, read locally by the same parser the
+   website uses (vendor/probe.js, copied from web/static — a test fails if the
+   copies drift). Nothing is uploaded to price a job, and the server measures
+   the file again on arrival: cheaper refunds the difference to the token,
+   dearer is refused and refunded whole. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlurwerkClient = exports.BlurwerkError = void 0;
+class BlurwerkError extends Error {
+    status;
+    constructor(message, status = 0) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.BlurwerkError = BlurwerkError;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const PROBE = require('./vendor/probe.js');
+class BlurwerkClient {
+    http;
+    base;
+    token;
+    sleep;
+    constructor(http, base, token = '', sleep = (ms) => new Promise((r) => setTimeout(r, ms))) {
+        this.http = http;
+        this.base = base;
+        this.token = token;
+        this.sleep = sleep;
+        this.base = base.replace(/\/+$/, '');
+    }
+    async call(method, path, json, auth = false) {
+        const headers = { Accept: 'application/json' };
+        if (auth)
+            headers.Authorization = `Bearer ${this.token}`;
+        const res = await this.http({ method, url: this.base + path, headers, json });
+        if (res.status >= 400) {
+            const said = res.body && (res.body.error || res.body.detail);
+            throw new BlurwerkError(`${method} ${path}: ${res.status} ${said || ''}`.trim(), res.status);
+        }
+        return res.body;
+    }
+    /** Duration, size and framerate from the file's own header, or null. */
+    static async probe(file) {
+        // A cast, not a copy: Node's Blob takes the Buffer as-is, and copying a
+        // multi-gigabyte video to satisfy a type would double the memory.
+        const blob = new Blob([file]);
+        try {
+            return await PROBE.read(blob);
+        }
+        catch {
+            return null;
+        }
+    }
+    static extension(name) {
+        const m = /\.[A-Za-z0-9]{1,5}$/.exec(name || '');
+        return m ? m[0].toLowerCase() : '.mp4';
+    }
+    async quote(meta, options, ext, size, stated) {
+        // The extension only — a filename is the customer's word for their own
+        // footage and is never sent (docs/API.md § 2).
+        return this.call('POST', '/api/quote', {
+            ext,
+            duration_s: meta.duration,
+            width: meta.width,
+            height: meta.height,
+            fps: meta.fps,
+            size_bytes: size,
+            stated,
+            ...options,
+            plates: false,
+        });
+    }
+    async balance() {
+        return this.call('GET', '/api/credits/balance', undefined, true);
+    }
+    async status(jobId) {
+        return this.call('GET', `/api/job/${encodeURIComponent(jobId)}`);
+    }
+    async reportProblem(jobId, reason, email) {
+        return this.call('POST', `/api/job/${encodeURIComponent(jobId)}/problem`, { reason, email });
+    }
+    /** Measure, quote, pay with credit and upload. Returns the paid job. */
+    async order(input) {
+        if (!input.consentWithdrawal || !input.consentCheck) {
+            throw new BlurwerkError('Both declarations are required: that work may start at once (§ 356(4) BGB) ' +
+                'and that the result will be checked before it is published.');
+        }
+        if (!this.token)
+            throw new BlurwerkError('No API token: buy credit at https://blurwerk.de/credit');
+        const read = await BlurwerkClient.probe(input.file);
+        const stated = input.stated || {};
+        const meta = read || {
+            duration: Number(stated.duration),
+            width: Number(stated.width),
+            height: Number(stated.height),
+            fps: Number(stated.fps) || 25,
+        };
+        if (!(meta.duration > 0 && meta.width > 0 && meta.height > 0)) {
+            throw new BlurwerkError('Could not read duration and size from this file. Set them under ' +
+                '"File Details" — the server measures the file again and refunds any difference.');
+        }
+        const q = await this.quote(meta, input.options, BlurwerkClient.extension(input.fileName), input.file.length, !read);
+        const jobId = q.job.id;
+        const paid = await this.call('POST', `/api/job/${jobId}/checkout`, {
+            provider: 'credits',
+            withdrawal_consent: true,
+            check_before_publish: true,
+            lang: input.options.lang,
+            email: input.email || '',
+        }, true);
+        await this.upload(jobId, input.file);
+        return { jobId, quote: q.job.quote, charged: paid.charged, balance: paid.balance, measured: !!read };
+    }
+    /** Multipart, straight to object storage (docs/API.md § 4). */
+    async upload(jobId, file) {
+        const start = await this.call('POST', `/api/job/${jobId}/upload/start`);
+        const size = start.part_size;
+        const count = Math.max(1, Math.ceil(file.length / size));
+        if (count > start.max_parts)
+            throw new BlurwerkError('file is too large for one order');
+        const etags = [];
+        for (let first = 1; first <= count; first += 10) {
+            const numbers = Array.from({ length: Math.min(10, count - first + 1) }, (_, i) => first + i);
+            const signed = await this.call('POST', `/api/job/${jobId}/upload/sign`, {
+                upload_id: start.upload_id,
+                parts: numbers,
+            });
+            for (const n of numbers) {
+                const chunk = file.subarray((n - 1) * size, n * size);
+                etags.push({ PartNumber: n, ETag: await this.putPart(signed.parts[String(n)], chunk) });
+            }
+        }
+        return this.call('POST', `/api/job/${jobId}/upload/complete`, {
+            upload_id: start.upload_id,
+            parts: etags,
+        });
+    }
+    async putPart(url, chunk, tries = 3) {
+        for (let attempt = 1;; attempt++) {
+            const res = await this.http({ method: 'PUT', url, raw: chunk });
+            const etag = res.headers.etag || res.headers.ETag;
+            if (res.status < 300 && etag)
+                return etag;
+            if (attempt >= tries)
+                throw new BlurwerkError(`part upload failed (${res.status})`, res.status);
+            await this.sleep(1000 * attempt);
+        }
+    }
+    /** Poll until done or failed; null if `maxWaitMs` passes first. */
+    async waitFor(jobId, maxWaitMs, everyMs) {
+        const until = Date.now() + maxWaitMs;
+        for (;;) {
+            const s = await this.status(jobId);
+            const state = s.job && s.job.state;
+            if (state === 'done' || state === 'failed' || s.expired)
+                return s;
+            if (Date.now() + everyMs > until)
+                return null;
+            await this.sleep(everyMs);
+        }
+    }
+    async download(url) {
+        const res = await this.http({ method: 'GET', url, binary: true });
+        if (res.status >= 400)
+            throw new BlurwerkError(`download failed (${res.status})`, res.status);
+        return Buffer.from(res.body);
+    }
+}
+exports.BlurwerkClient = BlurwerkClient;

package/dist/nodes/Blurwerk/properties.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.properties = void 0;
+const on = (...operation) => ({ displayOptions: { show: { operation } } });
+exports.properties = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        default: 'anonymize',
+        options: [
+            { name: 'Anonymize Video', value: 'anonymize', action: 'Anonymize a video',
+                description: 'Mosaic every face, optionally disguise or mute voices, and return the file' },
+            { name: 'Get Result', value: 'status', action: 'Get the result of a job',
+                description: 'State of an order, and the anonymized video once it is done' },
+            { name: 'Get Balance', value: 'balance', action: 'Get the credit balance' },
+            { name: 'Report Problem', value: 'problem', action: 'Report a problem and get a refund',
+                description: 'A delivered result that is not usable is refunded and deleted' },
+        ],
+    },
+    // --- anonymize -----------------------------------------------------------
+    {
+        displayName: 'Input Binary Field',
+        name: 'binaryPropertyName',
+        type: 'string',
+        default: 'data',
+        required: true,
+        hint: 'The video to anonymize. Its filename is never sent — only the extension.',
+        ...on('anonymize'),
+    },
+    {
+        displayName: 'Work May Start Immediately',
+        name: 'consentWithdrawal',
+        type: 'boolean',
+        default: false,
+        required: true,
+        description: 'Whether the person you act for asked for work to begin at once and accepts losing the 14-day right of withdrawal (§ 356(4) BGB). Required.',
+        ...on('anonymize'),
+    },
+    {
+        displayName: 'Result Will Be Checked Before Publishing',
+        name: 'consentCheck',
+        type: 'boolean',
+        default: false,
+        required: true,
+        description: 'Whether the result will be looked at before it is published. Detection is automatic and no rate is guaranteed; an unusable result is refunded. Required.',
+        ...on('anonymize'),
+    },
+    {
+        displayName: 'Wait for Result',
+        name: 'wait',
+        type: 'boolean',
+        default: true,
+        description: 'Whether to wait until the video is done and output it. Processing takes about twice the video length at 1080p and about eleven times at 4K.',
+        ...on('anonymize'),
+    },
+    {
+        displayName: 'Max Wait (Minutes)',
+        name: 'maxWait',
+        type: 'number',
+        default: 120,
+        typeOptions: { minValue: 1 },
+        displayOptions: { show: { operation: ['anonymize'], wait: [true] } },
+    },
+    {
+        displayName: 'Poll Every (Seconds)',
+        name: 'pollEvery',
+        type: 'number',
+        default: 30,
+        typeOptions: { minValue: 5 },
+        displayOptions: { show: { operation: ['anonymize'], wait: [true] } },
+    },
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        ...on('anonymize'),
+        options: [
+            {
+                displayName: 'Audio',
+                name: 'audio',
+                type: 'options',
+                default: 'keep',
+                options: [
+                    { name: 'Keep Original', value: 'keep', description: 'Speakers stay recognisable. Free.' },
+                    { name: 'Disguise Voice', value: 'robot',
+                        description: 'Pitch-shifted: words stay clear, the speaker does not. Can add units.' },
+                    { name: 'Mute', value: 'mute', description: 'Removes the audio track. Free.' },
+                ],
+            },
+            {
+                displayName: 'Sensitivity',
+                name: 'sensitivity',
+                type: 'options',
+                default: 'medium',
+                options: [
+                    { name: 'Confirmed Only', value: 'low', description: 'Two of three detectors must agree' },
+                    { name: 'Balanced', value: 'medium', description: 'Two agree, or one is sure' },
+                    { name: 'Everything', value: 'high', description: 'Any detector that sees a face' },
+                ],
+            },
+            {
+                displayName: 'Mosaic Size',
+                name: 'coverage',
+                type: 'options',
+                default: 'medium',
+                options: [
+                    { name: 'Tight', value: 'small' },
+                    { name: 'Normal', value: 'medium' },
+                    { name: 'Generous', value: 'large' },
+                ],
+            },
+            {
+                displayName: 'E-Mail for the Download Link',
+                name: 'email',
+                type: 'string',
+                placeholder: 'name@email.com',
+                default: '',
+            },
+            {
+                displayName: 'Language',
+                name: 'lang',
+                type: 'options',
+                default: 'en',
+                options: [
+                    { name: 'English', value: 'en' },
+                    { name: 'German', value: 'de' },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'File Details',
+        name: 'fileDetails',
+        type: 'collection',
+        placeholder: 'Add Detail',
+        default: {},
+        description: "Only needed when the file's header cannot be read. The server measures the file again: cheaper is refunded, dearer is refused and refunded.",
+        ...on('anonymize'),
+        options: [
+            { displayName: 'Duration (Seconds)', name: 'duration', type: 'number', default: 0 },
+            { displayName: 'Width (Px)', name: 'width', type: 'number', default: 0 },
+            { displayName: 'Height (Px)', name: 'height', type: 'number', default: 0 },
+            { displayName: 'Frames per Second', name: 'fps', type: 'number', default: 25 },
+        ],
+    },
+    // --- result / problem ----------------------------------------------------
+    {
+        displayName: 'Job ID',
+        name: 'jobId',
+        type: 'string',
+        default: '',
+        required: true,
+        ...on('status', 'problem'),
+    },
+    {
+        displayName: 'Download Video',
+        name: 'download',
+        type: 'boolean',
+        default: true,
+        description: 'Whether to output the finished video as binary data, rather than only its link',
+        displayOptions: { show: { operation: ['status', 'anonymize'] } },
+    },
+    {
+        displayName: 'Reason',
+        name: 'reason',
+        type: 'string',
+        typeOptions: { rows: 3 },
+        default: '',
+        required: true,
+        ...on('problem'),
+    },
+    {
+        displayName: 'E-Mail on the Order',
+        name: 'email',
+        type: 'string',
+        placeholder: 'name@email.com',
+        default: '',
+        required: true,
+        ...on('problem'),
+    },
+];

package/dist/nodes/Blurwerk/vendor/probe-stream.js

@@ -0,0 +1,246 @@
+/* Reading camcorder and broadcast streams in the browser: MPEG-TS (.ts, .m2ts,
+   .mts), MPEG program streams (.mpg, .vob) and FLV.
+
+   These used to be named and refused, and priced by hand through a form. They
+   are what AVCHD camcorders, dashcams and broadcast recorders write, so the
+   customers most likely to need faces removed were the ones typing numbers.
+
+   None of them keeps a tidy header with the three figures a price needs, so
+   they are measured the way ffprobe does: the length from the first and last
+   presentation timestamps, the framerate from the spacing between frames, and
+   the picture size from the codec's own sequence header (H.264 SPS, MPEG-2
+   sequence header). Nothing is uploaded; the head and tail of the file are
+   read here. Anything not understood returns null, and the page falls back to
+   asking — the server measures the real file on arrival either way.
+*/
+"use strict";
+
+const STREAM = (() => {
+  const EDGE = 2 << 20;                       // bytes read at each end
+  const TS_VIDEO = { 0x1B: "h264", 0x02: "mpeg2video", 0x01: "mpeg1video" };
+  const FPS_CODES = [0, 24000 / 1001, 24, 25, 30000 / 1001, 30, 50, 60000 / 1001, 60];
+
+  const slice = (file, a, b) => file.slice(Math.max(0, a), Math.min(b, file.size))
+    .arrayBuffer().then(x => new Uint8Array(x));
+
+  /* --- bit reading for codec headers -------------------------------------- */
+  function bits(bytes) {
+    const rbsp = [];                          // drop emulation-prevention 0x03
+    for (let i = 0; i < bytes.length; i++) {
+      if (i > 1 && bytes[i] === 3 && bytes[i - 1] === 0 && bytes[i - 2] === 0) continue;
+      rbsp.push(bytes[i]);
+    }
+    let pos = 0;
+    const u = n => { let v = 0; for (let i = 0; i < n; i++, pos++)
+      v = v * 2 + ((rbsp[pos >> 3] >> (7 - (pos & 7))) & 1); return v; };
+    const ue = () => { let z = 0; while (u(1) === 0) { if (++z > 31) throw 0; }
+      return (2 ** z) - 1 + u(z); };
+    const se = () => { const k = ue(); return k & 1 ? (k + 1) / 2 : -k / 2; };
+    return { u, ue, se };
+  }
+
+  function h264Size(nal) {                    // nal starts after the 1-byte header
+    const b = bits(nal);
+    const profile = b.u(8); b.u(16); b.ue();
+    let chroma = 1, separate = 0;
+    if ([100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134, 135].includes(profile)) {
+      chroma = b.ue(); if (chroma === 3) separate = b.u(1);
+      b.ue(); b.ue(); b.u(1);
+      if (b.u(1)) for (let i = 0; i < (chroma === 3 ? 12 : 8); i++) if (b.u(1)) {
+        let last = 8, next = 8;
+        for (let j = 0; j < (i < 6 ? 16 : 64); j++) {
+          if (next !== 0) next = (last + b.se() + 256) % 256;
+          last = next === 0 ? last : next;
+        }
+      }
+    }
+    b.ue();
+    const poc = b.ue();
+    if (poc === 0) b.ue();
+    else if (poc === 1) { b.u(1); b.se(); b.se(); const n = b.ue(); for (let i = 0; i < n; i++) b.se(); }
+    b.ue(); b.u(1);
+    const wMbs = b.ue() + 1, hMaps = b.ue() + 1, frameOnly = b.u(1);
+    if (!frameOnly) b.u(1);
+    b.u(1);
+    let cl = 0, cr = 0, ct = 0, cb = 0;
+    if (b.u(1)) { cl = b.ue(); cr = b.ue(); ct = b.ue(); cb = b.ue(); }
+    const cx = separate || chroma === 0 ? 1 : (chroma === 3 ? 1 : 2);
+    const cy = (separate || chroma === 0 ? 1 : (chroma === 1 ? 2 : 1)) * (2 - frameOnly);
+    return { width: wMbs * 16 - cx * (cl + cr),
+             height: (2 - frameOnly) * hMaps * 16 - cy * (ct + cb) };
+  }
+
+  // The first sequence header in a run of elementary-stream bytes.
+  function esSize(es, codec) {
+    for (let i = 0; i + 8 < es.length; i++) {
+      if (es[i] !== 0 || es[i + 1] !== 0 || es[i + 2] !== 1) continue;
+      if (codec === "h264" && (es[i + 3] & 0x1F) === 7) {
+        try { return h264Size(es.subarray(i + 4, i + 4 + 256)); } catch (e) { return null; }
+      }
+      if (codec !== "h264" && es[i + 3] === 0xB3) {
+        return { width: (es[i + 4] << 4) | (es[i + 5] >> 4),
+                 height: ((es[i + 5] & 0x0F) << 8) | es[i + 6],
+                 fps: FPS_CODES[es[i + 7] & 0x0F] || 0 };
+      }
+    }
+    return null;
+  }
+
+  function pts(p, off) {                      // PES header at off; 33-bit PTS or null
+    if (p[off] !== 0 || p[off + 1] !== 0 || p[off + 2] !== 1 || !(p[off + 7] & 0x80)) return null;
+    const q = off + 9;
+    return ((p[q] & 0x0E) * 2 ** 29) + (p[q + 1] << 22) + ((p[q + 2] & 0xFE) << 14)
+         + (p[q + 3] << 7) + (p[q + 4] >> 1);
+  }
+
+  // Frame spacing from a set of timestamps, which arrive in DECODE order, so
+  // sort them first. The smallest step is one frame.
+  function fpsFrom(stamps) {
+    const s = [...new Set(stamps)].sort((a, b) => a - b);
+    let step = Infinity;
+    for (let i = 1; i < s.length; i++) if (s[i] - s[i - 1] > 0) step = Math.min(step, s[i] - s[i - 1]);
+    return isFinite(step) ? 90000 / step : 0;
+  }
+
+  const finish = (m, container) => m && m.width > 15 && m.height > 15 && m.duration > 0.04
+    && m.fps > 0.5 && m.fps < 1000 ? Object.assign(m, { container }) : null;
+
+  /* --- MPEG transport stream ------------------------------------------------ */
+  function tsPackets(bytes, size) {
+    let start = 0;
+    while (start < size * 2 && !(bytes[start] === 0x47 && bytes[start + size] === 0x47)) start++;
+    const out = [];
+    // `start` is the sync byte itself; in M2TS it sits 4 bytes into each unit.
+    for (let i = start; i + 188 <= bytes.length; i += size) {
+      const p = bytes.subarray(i, i + 188);
+      if (p[0] !== 0x47) continue;
+      const pid = ((p[1] & 0x1F) << 8) | p[2], unit = !!(p[1] & 0x40), afc = (p[3] >> 4) & 3;
+      let off = 4; if (afc & 2) off += 1 + p[4];
+      if (afc & 1 && off < 188) out.push({ pid, unit, data: p.subarray(off) });
+    }
+    return out;
+  }
+
+  function tsVideo(packets) {                 // PAT -> PMT -> first video stream
+    const pat = packets.find(k => k.pid === 0 && k.unit);
+    if (!pat) return null;
+    const d = pat.data.subarray(1 + pat.data[0]);
+    const pmtPid = ((d[10] & 0x1F) << 8) | d[11];
+    const pmt = packets.find(k => k.pid === pmtPid && k.unit);
+    if (!pmt) return null;
+    const m = pmt.data.subarray(1 + pmt.data[0]);
+    const end = 3 + (((m[1] & 0x0F) << 8) | m[2]) - 4;
+    for (let i = 12 + (((m[10] & 0x0F) << 8) | m[11]); i + 5 <= end;) {
+      const type = m[i], pid = ((m[i + 1] & 0x1F) << 8) | m[i + 2];
+      if (TS_VIDEO[type]) return { pid, codec: TS_VIDEO[type] };
+      i += 5 + (((m[i + 3] & 0x0F) << 8) | m[i + 4]);
+    }
+    return null;
+  }
+
+  async function readTS(file, size) {
+    const head = tsPackets(await slice(file, 0, EDGE), size);
+    const video = tsVideo(head);
+    if (!video) return null;
+    const mine = head.filter(k => k.pid === video.pid);
+    const stamps = mine.filter(k => k.unit).map(k => pts(k.data, 0)).filter(x => x !== null);
+    const tail = tsPackets(await slice(file, file.size - EDGE, file.size), size)
+      .filter(k => k.pid === video.pid && k.unit).map(k => pts(k.data, 0)).filter(x => x !== null);
+    if (!stamps.length || !tail.length) return null;
+    const shape = esSize(Uint8Array.from(mine.flatMap(k => [...k.data])), video.codec);
+    if (!shape) return null;
+    const fps = fpsFrom(stamps) || shape.fps;
+    let span = Math.max(...tail) - Math.min(...stamps);
+    if (span < 0) span += 2 ** 33;            // the 33-bit clock wrapped
+    return finish({ width: shape.width, height: shape.height, fps, codec: video.codec,
+                    duration: span / 90000 + (fps ? 1 / fps : 0) },
+                  size === 192 ? "MPEG-TS (M2TS)" : "MPEG-TS");
+  }
+
+  /* --- MPEG program stream (.mpg, .vob) ------------------------------------ */
+  function psStamps(b) {
+    const out = [];
+    for (let i = 0; i + 14 < b.length; i++)
+      if (b[i] === 0 && b[i + 1] === 0 && b[i + 2] === 1 && (b[i + 3] & 0xF0) === 0xE0) {
+        const t = pts(b, i); if (t !== null) out.push(t);
+      }
+    return out;
+  }
+
+  async function readPS(file) {
+    const head = await slice(file, 0, EDGE), tail = await slice(file, file.size - EDGE, file.size);
+    const shape = esSize(head, "mpeg2video");
+    const a = psStamps(head), z = psStamps(tail);
+    if (!shape || !a.length || !z.length) return null;
+    const fps = shape.fps || fpsFrom(a);
+    return finish({ width: shape.width, height: shape.height, fps, codec: "mpeg2video",
+                    duration: (Math.max(...z) - Math.min(...a)) / 90000 + 1 / fps },
+                  "MPEG program stream");
+  }
+
+  /* --- FLV ---------------------------------------------------------------------- */
+  const FLV_CODEC = { 2: "flv1", 3: "screen", 4: "vp6", 5: "vp6a", 7: "h264", 12: "hevc" };
+
+  function amf(v, o) {                        // one AMF0 value at o -> [value, next]
+    const t = v[o++], dv = new DataView(v.buffer, v.byteOffset);
+    const str = (at, n) => [new TextDecoder().decode(v.subarray(at, at + n)), at + n];
+    if (t === 0) return [dv.getFloat64(o), o + 8];
+    if (t === 1) return [!!v[o], o + 1];
+    if (t === 2) return str(o + 2, dv.getUint16(o));
+    if (t === 3 || t === 8) {
+      const out = {}; if (t === 8) o += 4;
+      for (let guard = 0; guard < 512; guard++) {
+        const n = dv.getUint16(o); if (n === 0 && v[o + 2] === 9) return [out, o + 3];
+        const [k, at] = str(o + 2, n); const [val, next] = amf(v, at); out[k] = val; o = next;
+      }
+      return [out, o];
+    }
+    if (t === 5 || t === 6) return [null, o];
+    if (t === 10) { const n = dv.getUint32(o); o += 4; const a = [];
+      for (let i = 0; i < n && i < 4096; i++) { const [x, next] = amf(v, o); a.push(x); o = next; }
+      return [a, o]; }
+    if (t === 11) return [dv.getFloat64(o), o + 10];
+    throw new Error("amf");
+  }
+
+  async function readFLV(file) {
+    const v = await slice(file, 0, EDGE), dv = new DataView(v.buffer);
+    let o = dv.getUint32(5) + 4, meta = {}, stamps = [], codec = "";
+    while (o + 11 < v.length && stamps.length < 60) {
+      const type = v[o], size = (v[o + 1] << 16) | (v[o + 2] << 8) | v[o + 3];
+      const ts = ((v[o + 7] << 24) | (v[o + 4] << 16) | (v[o + 5] << 8) | v[o + 6]) >>> 0;
+      if (type === 18) {
+        try { const [name, at] = amf(v, o + 11); if (name === "onMetaData") meta = amf(v, at)[0] || {}; }
+        catch (e) { /* metadata is optional */ }
+      } else if (type === 9) { stamps.push(ts * 90); codec = codec || FLV_CODEC[v[o + 11] & 0x0F] || ""; }
+      o += 11 + size + 4;
+    }
+    let duration = meta.duration;
+    if (!(duration > 0)) {                    // streamed: no duration written
+      const t = await slice(file, file.size - 4, file.size);
+      const last = new DataView(t.buffer).getUint32(0);
+      const tag = await slice(file, file.size - 4 - last, file.size - 4 - last + 8);
+      duration = (((tag[7] << 24) | (tag[4] << 16) | (tag[5] << 8) | tag[6]) >>> 0) / 1000;
+    }
+    const fps = meta.framerate || fpsFrom(stamps);
+    return finish({ width: meta.width, height: meta.height, fps, duration,
+                    codec: codec || String(meta.videocodecid || "") }, "FLV");
+  }
+
+  /* --- dispatch ------------------------------------------------------------------ */
+  async function read(file) {
+    const h = await slice(file, 0, 400);
+    if (h.length < 16) return null;
+    try {
+      if (h[0] === 0x46 && h[1] === 0x4C && h[2] === 0x56) return await readFLV(file);
+      if (h[0] === 0x47 && h[188] === 0x47) return await readTS(file, 188);
+      if (h[4] === 0x47 && h[196] === 0x47) return await readTS(file, 192);
+      if (h[0] === 0 && h[1] === 0 && h[2] === 1 && h[3] === 0xBA) return await readPS(file);
+    } catch (e) { return null; }
+    return null;
+  }
+
+  return { read, h264Size, fpsFrom };
+})();
+
+if (typeof module !== "undefined") module.exports = STREAM;   // tests

package/dist/nodes/Blurwerk/vendor/probe.js

@@ -0,0 +1,284 @@
+/* Container header parsing, in the browser.
+
+   The browser can only tell us a video's dimensions if it can DECODE it, and
+   it refuses most of what people actually have: Matroska in any form, HEVC,
+   AVI, ProRes. Those files were being rejected at the door with "is it a
+   video?" while the FAQ promised we accept them.
+
+   Reading the header ourselves fixes that without breaking the promise that
+   nothing is uploaded to price a job — we parse the same fields ffprobe would,
+   from a slice of the file, on the customer's own machine.
+
+   Every parser returns null rather than a guess. A wrong duration is a wrong
+   price, and a wrong price is money. */
+"use strict";
+
+const CONTAINER = (() => {
+
+  const buf = (file, start, end) =>
+    file.slice(start, Math.min(end, file.size)).arrayBuffer().then(b => new DataView(b));
+  const ascii = (v, off, n) => {
+    let s = "";
+    for (let i = 0; i < n; i++) s += String.fromCharCode(v.getUint8(off + i));
+    return s;
+  };
+  // Plausibility, applied to every parser's output. Nonsense is worse than a
+  // failure: a failure asks the customer, nonsense quietly misprices the job.
+  const sane = m =>
+    m && m.width > 15 && m.height > 15 && m.width < 33000 && m.height < 33000
+      && m.duration > 0.04 && m.duration < 86400 * 2
+      && m.fps > 0.5 && m.fps < 1000 ? m : null;
+
+  /* --- Matroska / WebM (EBML) --------------------------------------------- */
+  // Elements are id + size + payload, both written as variable-length ints.
+  // Ids keep their marker bits (that is how the spec writes them); sizes have
+  // theirs stripped.
+
+  const HEAD_BYTES = 4 << 20;   // Info and Tracks precede the first Cluster
+
+  function vint(v, off, keepMarker) {
+    const first = v.getUint8(off);
+    if (first === 0) return null;                     // reserved / corrupt
+    let len = 1;
+    for (let mask = 0x80; !(first & mask); mask >>= 1) len++;
+    let value = keepMarker ? first : first & (0xff >> len);
+    for (let i = 1; i < len; i++) value = value * 256 + v.getUint8(off + i);
+    return { value, len };
+  }
+
+  const uint = (v, off, n) => {
+    let x = 0;
+    for (let i = 0; i < n; i++) x = x * 256 + v.getUint8(off + i);
+    return x;
+  };
+
+  // Walk one level of children, calling visit(id, payloadOffset, size). Return
+  // true from visit to descend into that element instead of skipping it.
+  //
+  // Depth is capped because a file can nest as deeply as it likes: Segment
+  // inside Segment inside Segment costs nothing to write and would recurse
+  // until the tab's stack gave out. Real files nest four levels.
+  const MAX_DEPTH = 8;
+
+  function ebmlWalk(v, off, end, visit, depth) {
+    if ((depth || 0) > MAX_DEPTH) return;
+    while (off < end) {
+      const id = vint(v, off, true);
+      if (!id) return;
+      const sz = vint(v, off + id.len, false);
+      if (!sz) return;
+      const start = off + id.len + sz.len;
+      // A size of all ones means "unknown" — descend rather than skip.
+      const unknown = sz.value >= Math.pow(2, 7 * sz.len) - 1;
+      const stop = unknown ? end : Math.min(end, start + sz.value);
+      if (visit(id.value, start, stop) === true)
+        ebmlWalk(v, start, stop, visit, (depth || 0) + 1);
+      if (unknown) return;
+      off = stop;
+      if (stop <= start && sz.value !== 0) return;    // no forward progress
+    }
+  }
+
+  const text = (v, off, n) => {
+    let s = "";
+    for (let i = 0; i < n; i++) {
+      const c = v.getUint8(off + i);
+      if (c === 0) break;
+      s += String.fromCharCode(c);
+    }
+    return s;
+  };
+
+  function parseEBML(v, raw) {
+    let scale = 1e6, ticks = 0, w = 0, h = 0, frameNs = 0, codec = "";
+    let type = 0, trackW = 0, trackH = 0, trackNs = 0, trackCodec = "";
+    ebmlWalk(v, 0, v.byteLength, (id, at, to) => {
+      const n = to - at;
+      switch (id) {
+        case 0x18538067: case 0x1549A966: case 0x1654AE6B: return true;  // Segment/Info/Tracks
+        case 0x2AD7B1: scale = uint(v, at, n) || scale; return;          // TimestampScale
+        case 0x4489:                                                      // Duration (float)
+          ticks = n === 4 ? v.getFloat32(at) : n === 8 ? v.getFloat64(at) : ticks; return;
+        case 0xAE:                                                        // TrackEntry
+          type = trackW = trackH = trackNs = 0; trackCodec = "";
+          ebmlWalk(v, at, to, (tid, tat, tto) => {
+            const tn = tto - tat;
+            if (tid === 0x83) type = uint(v, tat, tn);                    // TrackType
+            else if (tid === 0x86) trackCodec = text(v, tat, tn);          // CodecID
+            else if (tid === 0x23E383) trackNs = uint(v, tat, tn);        // DefaultDuration
+            else if (tid === 0xE0) return true;                           // Video
+            else if (tid === 0xB0) trackW = uint(v, tat, tn);             // PixelWidth
+            else if (tid === 0xBA) trackH = uint(v, tat, tn);             // PixelHeight
+          });
+          if (type === 1 && !w) {
+            w = trackW; h = trackH; frameNs = trackNs; codec = trackCodec;
+          }
+          return;
+      }
+    });
+    const out = { width: w, height: h, duration: ticks * scale / 1e9,
+                  fps: frameNs ? 1e9 / frameNs : 0,
+                  container: "Matroska/WebM", codec };
+    return raw ? out : sane(out);
+  }
+
+  /* --- MP4 / MOV (ISO base media) ----------------------------------------- */
+  // moov sits at either end of the file, so top-level boxes are walked by
+  // reading 16-byte headers and seeking — never by reading the whole file.
+
+  async function findMoov(file) {
+    let off = 0;
+    while (off + 8 <= file.size) {
+      const v = await buf(file, off, off + 16);
+      if (v.byteLength < 8) return null;
+      let size = v.getUint32(0), head = 8;
+      const type = ascii(v, 4, 4);
+      if (size === 1) {
+        if (v.byteLength < 16) return null;
+        size = v.getUint32(8) * 4294967296 + v.getUint32(12);
+        head = 16;
+      } else if (size === 0) size = file.size - off;
+      if (type === "moov") return { start: off + head, end: off + size };
+      if (size < 8) return null;
+      off += size;
+    }
+    return null;
+  }
+
+  // Children of one box, as {type, at, to} — boxes here are small enough that
+  // the whole moov is already in memory.
+  function boxes(v, off, end) {
+    const out = [];
+    while (off + 8 <= end) {
+      let size = v.getUint32(off), head = 8;
+      const type = ascii(v, off + 4, 4);
+      if (size === 1) { size = v.getUint32(off + 8) * 4294967296 + v.getUint32(off + 12); head = 16; }
+      else if (size === 0) size = end - off;
+      if (size < head) return out;
+      out.push({ type, at: off + head, to: Math.min(end, off + size) });
+      off += size;
+    }
+    return out;
+  }
+
+  const find = (v, list, type) => list.find(b => b.type === type);
+
+  function parseMoov(v, end, raw) {
+    const moov = boxes(v, 0, end);
+    for (const trak of moov.filter(b => b.type === "trak")) {
+      const t = boxes(v, trak.at, trak.to);
+      const mdia = find(v, t, "mdia");
+      if (!mdia) continue;
+      const md = boxes(v, mdia.at, mdia.to);
+      const hdlr = find(v, md, "hdlr");
+      if (!hdlr || ascii(v, hdlr.at + 8, 4) !== "vide") continue;
+
+      const mdhd = find(v, md, "mdhd");
+      if (!mdhd) continue;
+      const v1 = v.getUint8(mdhd.at) === 1;
+      const timescale = v1 ? v.getUint32(mdhd.at + 20) : v.getUint32(mdhd.at + 12);
+      const dur = v1 ? v.getUint32(mdhd.at + 24) * 4294967296 + v.getUint32(mdhd.at + 28)
+                     : v.getUint32(mdhd.at + 16);
+      const duration = timescale ? dur / timescale : 0;
+
+      const minf = find(v, md, "minf");
+      const stbl = minf && find(v, boxes(v, minf.at, minf.to), "stbl");
+      if (!stbl) continue;
+      const st = boxes(v, stbl.at, stbl.to);
+
+      // Coded size from the sample description, not tkhd: tkhd carries the
+      // DISPLAY size, which differs on anamorphic footage.
+      let width = 0, height = 0, codec = "";
+      const stsd = find(v, st, "stsd");
+      if (stsd && v.getUint32(stsd.at + 4) > 0) {
+        const entry = stsd.at + 8;
+        // The sample entry's own four-character type IS the codec: avc1, hvc1,
+        // hev1, av01, vp09, ap4h for ProRes.
+        codec = ascii(v, entry + 4, 4);
+        width = v.getUint16(entry + 24);
+        height = v.getUint16(entry + 26);
+      }
+      if (!width) {
+        const tkhd = find(v, t, "tkhd");
+        if (tkhd) {
+          const off = v.getUint8(tkhd.at) === 1 ? 88 : 76;
+          width = v.getUint32(tkhd.at + off) / 65536;
+          height = v.getUint32(tkhd.at + off + 4) / 65536;
+        }
+      }
+
+      const stsz = find(v, st, "stsz");
+      const samples = stsz ? v.getUint32(stsz.at + 8) : 0;
+      const out = { width, height, duration,
+                    fps: duration ? samples / duration : 0,
+                    container: "MP4/MOV", codec };
+      return raw ? out : sane(out);
+    }
+    return null;
+  }
+
+  /* --- AVI (RIFF) ---------------------------------------------------------- */
+
+  function parseAVI(v, raw) {
+    // hdrl/avih sits immediately after the 12-byte RIFF header in every file
+    // ffmpeg or a camera writes; anything else falls through to null.
+    const list = boxes4cc(v, 12, v.byteLength, "avih");
+    if (!list) return null;
+    const usPerFrame = v.getUint32(list, true);
+    const frames = v.getUint32(list + 16, true);
+    const fps = usPerFrame ? 1e6 / usPerFrame : 0;
+    const out = { width: v.getUint32(list + 32, true),
+                  height: v.getUint32(list + 36, true),
+                  duration: fps ? frames / fps : 0, fps,
+                  container: "AVI", codec: "" };
+    return raw ? out : sane(out);
+  }
+
+  // RIFF chunks are little-endian and LIST chunks nest; find one payload.
+  // Depth-capped for the same reason as ebmlWalk: nesting is free to write.
+  function boxes4cc(v, off, end, want, depth) {
+    if ((depth || 0) > MAX_DEPTH) return null;
+    while (off + 8 <= end) {
+      const id = ascii(v, off, 4);
+      const size = v.getUint32(off + 4, true);
+      if (id === want) return off + 8;
+      if (id === "LIST") {
+        const hit = boxes4cc(v, off + 12, Math.min(end, off + 8 + size), want,
+                             (depth || 0) + 1);
+        if (hit) return hit;
+      }
+      off += 8 + size + (size & 1);
+    }
+    return null;
+  }
+
+  /* --- dispatch ------------------------------------------------------------ */
+
+  async function moovMeta(file, raw) {
+    const moov = await findMoov(file);
+    if (!moov) return null;
+    return parseMoov(await buf(file, moov.start, moov.end),
+                     moov.end - moov.start, raw);
+  }
+
+  // Streams (TS, M2TS, MPEG-PS, FLV) live in probe-stream.js, loaded before
+  // this file in the page and required under the test runner.
+  const stream = () => typeof STREAM !== "undefined" ? STREAM
+    : (typeof require !== "undefined" ? require("./probe-stream.js") : null);
+
+  async function read(file) {
+    const head = await buf(file, 0, 16);
+    if (head.byteLength < 12) return null;
+    if (head.getUint32(0) === 0x1A45DFA3)
+      return parseEBML(await buf(file, 0, HEAD_BYTES));
+    if (ascii(head, 0, 4) === "RIFF" && ascii(head, 8, 4) === "AVI ")
+      return parseAVI(await buf(file, 0, HEAD_BYTES));
+    const s = stream() && await stream().read(file);
+    return s || await moovMeta(file, false);
+  }
+
+  return { read, moovMeta, buf, ascii, parseEBML, parseMoov, parseAVI,
+           boxes, findMoov };
+})();
+
+if (typeof module !== "undefined") module.exports = CONTAINER;   // tests

package/index.js

@@ -0,0 +1 @@
+module.exports = {};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "n8n-nodes-blurwerk",
+  "version": "0.1.0",
+  "description": "n8n node for blurwerk: anonymize video — every face mosaiced, voices disguised or muted, metadata removed. Processed in Germany.",
+  "keywords": [
+    "n8n-community-node-package",
+    "video",
+    "anonymization",
+    "gdpr",
+    "dsgvo",
+    "face blur",
+    "privacy"
+  ],
+  "license": "MIT",
+  "homepage": "https://blurwerk.de/?ref=n8n",
+  "author": {
+    "name": "blurwerk",
+    "email": "contact@blurwerk.de"
+  },
+  "main": "index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "vendor": "node scripts/vendor.mjs",
+    "build": "node scripts/vendor.mjs && tsc && node scripts/assets.mjs",
+    "test": "npm run build && node --test test/",
+    "prepublishOnly": "npm test && node scripts/check-publish.mjs"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "strict": true,
+    "credentials": [
+      "dist/credentials/BlurwerkApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Blurwerk/Blurwerk.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "n8n-workflow": "2.16.0",
+    "typescript": "^5.6.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}