ep_bounded_timeslider_api 0.1.0

package/LICENSE

@@ -0,0 +1,189 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Daniel Castelone
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,76 @@
+# ep_bounded_timeslider_api
+
+Bounded, server-side Etherpad timeslider API endpoints for assessment workflows. The plugin reads exact revision ranges, preserves Etherpad attribution, and can return a complete attributed diff snapshot for downstream rendering.
+
+## Features
+
+- API-key-authenticated, read-only HTTP endpoints
+- Inclusive, bounded revision ranges
+- Exact additions grouped by Etherpad author
+- Attributed text segments for safe downstream rendering
+- Complete before, after, and diff snapshots
+- Visible author list in Etherpad's embedded timeslider
+
+## Installation
+
+From the Etherpad directory:
+
+```sh
+pnpm run plugins i ep_bounded_timeslider_api
+```
+
+Restart Etherpad after installation. This release supports Etherpad 3.3.2 and later 3.x releases.
+
+## Authentication
+
+Both endpoints require Etherpad's API key. Prefer either request header:
+
+```text
+apikey: <etherpad-api-key>
+x-api-key: <etherpad-api-key>
+```
+
+Query-string API keys are accepted for Etherpad API compatibility but are discouraged because URLs can be retained in logs and browser history. Expose these endpoints only on trusted server-to-server ingress.
+
+## Authored revision report
+
+`GET /pluginfw/ep_bounded_timeslider_api/revisions`
+
+| Parameter | Required | Description |
+| --- | --- | --- |
+| `padID` | Yes | Etherpad pad ID |
+| `startRev` | No | First included revision |
+| `endRev` | No | Last included revision |
+| `authorIDs` | No | Comma-separated Etherpad author IDs, up to 50 |
+| `excerptChars` | No | Text excerpt length; defaults to 500 and is capped at 2,000 |
+
+The response contains revision timestamps, revision authors, and exact additions. Insert operations without an operation-level author attribute fall back to the stored revision author.
+
+## Attributed snapshot report
+
+`GET /pluginfw/ep_bounded_timeslider_api/snapshot`
+
+This endpoint accepts `padID`, `startRev`, and `endRev`. It returns Etherpad's attributed diff lines plus `beforeLines` and `afterLines`, allowing a consumer to reconstruct semantic structures when a plugin rewrites a complete line for a smaller edit.
+
+## Limits
+
+- Default maximum range: 1,200 revisions
+- Hard maximum range: 5,000 revisions
+- Default read batch: 50 revisions
+- Maximum read batch: 100 revisions
+
+The deployment can set:
+
+```text
+EP_BOUNDED_TIMESLIDER_API_MAX_REVISIONS=1200
+EP_BOUNDED_TIMESLIDER_API_BATCH_SIZE=50
+```
+
+## Development
+
+```sh
+pnpm install --frozen-lockfile
+pnpm test
+```
+
+Licensed under the Apache License 2.0.

package/ep.json

@@ -0,0 +1,13 @@
+{
+  "parts": [
+    {
+      "name": "bounded_timeslider_api",
+      "hooks": {
+        "expressPreSession": "ep_bounded_timeslider_api/index"
+      },
+      "client_hooks": {
+        "postAceInit": "ep_bounded_timeslider_api/static/js/history-authors:postAceInit"
+      }
+    }
+  ]
+}

package/index.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const log4js = require('log4js');
+const padManager = require('ep_etherpad-lite/node/db/PadManager');
+const apiKeyHandler = require('ep_etherpad-lite/node/handler/APIKeyHandler');
+const Changeset = require('ep_etherpad-lite/static/js/Changeset');
+const attributes = require('ep_etherpad-lite/static/js/attributes');
+const PadDiff = require('ep_etherpad-lite/node/utils/padDiff');
+const {isValidApiKey} = require('./lib/auth');
+const {normalizeRange, readRevisionReport} = require('./lib/report');
+const {serializeAText} = require('./lib/snapshot');
+
+const logger = log4js.getLogger('ep_bounded_timeslider_api');
+const DEFAULT_MAX_REVISIONS = 1200;
+const HARD_MAX_REVISIONS = 5000;
+const DEFAULT_BATCH_SIZE = 50;
+const DEFAULT_EXCERPT_CHARS = 500;
+
+const positiveInteger = (value, fallback) => {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+};
+
+const parseOptionalInteger = (value, name) => {
+  if (value == null || value === '') return undefined;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) throw new TypeError(`${name} must be an integer`);
+  return parsed;
+};
+
+const parseAuthorIds = (value) => {
+  if (value == null || value === '') return null;
+  const authorIds = String(value).split(',').map((id) => id.trim()).filter(Boolean);
+  if (authorIds.length > 50) throw new RangeError('authorIDs accepts at most 50 authors');
+  if (authorIds.some((id) => id.length > 100 || !/^a\.[A-Za-z0-9_-]+$/.test(id))) {
+    throw new TypeError('authorIDs contains an invalid Etherpad author ID');
+  }
+  return new Set(authorIds);
+};
+
+const providedApiKey = (req) =>
+  req.get('apikey') || req.get('x-api-key') || req.query.apikey || req.query.api_key || '';
+
+exports.expressPreSession = async (_hookName, {app}) => {
+  app.get('/pluginfw/ep_bounded_timeslider_api/revisions', async (req, res) => {
+    const startedAt = Date.now();
+    try {
+      if (!isValidApiKey(providedApiKey(req), apiKeyHandler.apikey)) {
+        return res.status(401).json({code: 4, message: 'no or wrong API Key', data: null});
+      }
+
+      const padID = String(req.query.padID || '');
+      if (!padManager.isValidPadId(padID)) {
+        return res.status(400).json({code: 1, message: 'invalid padID', data: null});
+      }
+      if (!await padManager.doesPadExist(padID)) {
+        return res.status(404).json({code: 1, message: 'padID does not exist', data: null});
+      }
+
+      const configuredMax = Math.min(
+          positiveInteger(process.env.EP_BOUNDED_TIMESLIDER_API_MAX_REVISIONS, DEFAULT_MAX_REVISIONS),
+          HARD_MAX_REVISIONS);
+      const batchSize = Math.min(
+          positiveInteger(process.env.EP_BOUNDED_TIMESLIDER_API_BATCH_SIZE, DEFAULT_BATCH_SIZE),
+          100);
+      const excerptChars = Math.min(
+          positiveInteger(req.query.excerptChars, DEFAULT_EXCERPT_CHARS),
+          2000);
+      const authorIds = parseAuthorIds(req.query.authorIDs);
+      const pad = await padManager.getPad(padID);
+      const range = normalizeRange(
+          pad.getHeadRevisionNumber(),
+          parseOptionalInteger(req.query.startRev, 'startRev'),
+          parseOptionalInteger(req.query.endRev, 'endRev'),
+          configuredMax);
+
+      const report = await readRevisionReport({
+        pad,
+        range,
+        batchSize,
+        excerptChars,
+        authorIds,
+        changeset: Changeset,
+        attributes,
+      });
+
+      logger.info('bounded timeslider revision report generated', {
+        padID,
+        startRev: range.startRev,
+        endRev: range.endRev,
+        revisions: report.revisions.length,
+        durationMs: Date.now() - startedAt,
+      });
+      return res.json({code: 0, message: 'ok', data: {padID, ...report}});
+    } catch (err) {
+      const status = err instanceof RangeError ? 413 :
+        err instanceof TypeError ? 400 : 500;
+      if (status === 500) logger.error('bounded timeslider revision report failed', err);
+      return res.status(status).json({
+        code: 1,
+        message: status === 500 ? 'failed to generate bounded timeslider report' : err.message,
+        data: null,
+      });
+    }
+  });
+
+  app.get('/pluginfw/ep_bounded_timeslider_api/snapshot', async (req, res) => {
+    const startedAt = Date.now();
+    try {
+      if (!isValidApiKey(providedApiKey(req), apiKeyHandler.apikey)) {
+        return res.status(401).json({code: 4, message: 'no or wrong API Key', data: null});
+      }
+      const padID = String(req.query.padID || '');
+      if (!padManager.isValidPadId(padID)) {
+        return res.status(400).json({code: 1, message: 'invalid padID', data: null});
+      }
+      if (!await padManager.doesPadExist(padID)) {
+        return res.status(404).json({code: 1, message: 'padID does not exist', data: null});
+      }
+
+      const pad = await padManager.getPad(padID);
+      const configuredMax = Math.min(
+          positiveInteger(process.env.EP_BOUNDED_TIMESLIDER_API_MAX_REVISIONS, DEFAULT_MAX_REVISIONS),
+          HARD_MAX_REVISIONS);
+      const range = normalizeRange(
+          pad.getHeadRevisionNumber(),
+          parseOptionalInteger(req.query.startRev, 'startRev'),
+          parseOptionalInteger(req.query.endRev, 'endRev'),
+          configuredMax);
+      const diff = new PadDiff(pad, String(range.startRev), String(range.endRev));
+      const [atext, beforeAText, afterAText] = await Promise.all([
+        diff._createDiffAtext(),
+        pad.getInternalRevisionAText(range.startRev),
+        pad.getInternalRevisionAText(range.endRev),
+      ]);
+      const serialize = (value) => serializeAText({
+        atext: value, pool: pad.apool(), changeset: Changeset, attributes,
+      });
+      const lines = serialize(atext);
+      const beforeLines = serialize(beforeAText);
+      const afterLines = serialize(afterAText);
+
+      logger.info('snapshot generated', {
+        padID, startRev: range.startRev, endRev: range.endRev,
+        lines: lines.length, durationMs: Date.now() - startedAt,
+      });
+      return res.json({code: 0, message: 'ok', data: {padID, ...range, lines, beforeLines, afterLines}});
+    } catch (err) {
+      const status = err instanceof RangeError ? 413 : err instanceof TypeError ? 400 : 500;
+      if (status === 500) logger.error('snapshot failed', err);
+      return res.status(status).json({
+        code: 1,
+        message: status === 500 ? 'failed to generate contribution snapshot' : err.message,
+        data: null,
+      });
+    }
+  });
+};

package/lib/auth.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const isValidApiKey = (provided, expected) => {
+  const wanted = String(expected || '').trim();
+  if (!wanted) return false;
+  const actualBuffer = Buffer.from(String(provided || ''), 'utf8');
+  const wantedBuffer = Buffer.from(wanted, 'utf8');
+  return actualBuffer.length === wantedBuffer.length &&
+    crypto.timingSafeEqual(actualBuffer, wantedBuffer);
+};
+
+module.exports = {isValidApiKey};

package/lib/report.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const normalizeRange = (headRevision, requestedStart, requestedEnd, maxRevisions) => {
+  if (!Number.isInteger(headRevision) || headRevision < 0) {
+    throw new RangeError('pad has no reportable revisions');
+  }
+  const endRev = requestedEnd == null ? headRevision : requestedEnd;
+  const startRev = requestedStart == null ? Math.max(0, endRev - maxRevisions + 1) : requestedStart;
+  if (!Number.isInteger(startRev) || startRev < 0) throw new TypeError('startRev must be a non-negative integer');
+  if (!Number.isInteger(endRev) || endRev < startRev) throw new TypeError('endRev must be at least startRev');
+  if (endRev > headRevision) throw new RangeError('endRev is higher than the pad head revision');
+  if (endRev - startRev + 1 > maxRevisions) {
+    throw new RangeError(`requested revision range exceeds the ${maxRevisions} revision limit`);
+  }
+  return {startRev, endRev, headRevision, revisionCount: headRevision + 1};
+};
+
+const readOperationAttributes = (attribString, pool, attributes) => {
+  const operationAttributes = [];
+  for (const attributeNumber of attributes.decodeAttribString(attribString)) {
+    const pair = pool.getAttrib(attributeNumber);
+    if (pair) operationAttributes.push(pair);
+  }
+  return operationAttributes;
+};
+
+const summarizeRevision = ({rev, record, pool, authorIds, excerptChars, changeset, attributes}) => {
+  const timestamp = Number(record?.meta?.timestamp);
+  if (!Number.isFinite(timestamp) || timestamp <= 0) {
+    throw new Error(`revision ${rev} has an invalid timestamp`);
+  }
+  const revisionAuthorId = String(record?.meta?.author || '');
+  const unpacked = changeset.unpack(record.changeset);
+  const additions = new Map();
+  let bankOffset = 0;
+
+  for (const op of changeset.deserializeOps(unpacked.ops)) {
+    if (op.opcode !== '+') continue;
+    const text = unpacked.charBank.slice(bankOffset, bankOffset + op.chars);
+    bankOffset += op.chars;
+    const operationAttributes = readOperationAttributes(op.attribs, pool, attributes);
+    const authorAttribute = operationAttributes.find(([key]) => key === 'author');
+    const authorId = authorAttribute?.[1] || revisionAuthorId;
+    if (!authorId || (authorIds && !authorIds.has(authorId))) continue;
+
+    let item = additions.get(authorId);
+    if (!item) {
+      item = {authorId, chars: 0, text: '', textTruncated: false, segments: []};
+      additions.set(authorId, item);
+    }
+    item.chars += op.chars;
+    const remaining = Math.max(0, excerptChars - item.text.length);
+    const excerpt = text.slice(0, remaining);
+    item.text += excerpt;
+    if (excerpt) {
+      item.segments.push({
+        text: excerpt,
+        attributes: operationAttributes.filter(([key]) => key !== 'author'),
+      });
+    }
+    if (text.length > remaining) item.textTruncated = true;
+  }
+
+  return {
+    rev,
+    timestamp,
+    revisionAuthorId,
+    additions: Array.from(additions.values()),
+  };
+};
+
+const readRevisionReport = async ({
+  pad,
+  range,
+  batchSize,
+  excerptChars,
+  authorIds,
+  changeset,
+  attributes,
+}) => {
+  const revisions = [];
+  const pool = pad.apool();
+  for (let batchStart = range.startRev; batchStart <= range.endRev; batchStart += batchSize) {
+    const batchEnd = Math.min(range.endRev, batchStart + batchSize - 1);
+    const revisionNumbers = [];
+    for (let rev = batchStart; rev <= batchEnd; rev += 1) revisionNumbers.push(rev);
+    const records = await Promise.all(revisionNumbers.map((rev) => pad.getRevision(rev)));
+    for (let i = 0; i < revisionNumbers.length; i += 1) {
+      revisions.push(summarizeRevision({
+        rev: revisionNumbers[i],
+        record: records[i],
+        pool,
+        authorIds,
+        excerptChars,
+        changeset,
+        attributes,
+      }));
+    }
+  }
+
+  return {...range, revisions};
+};
+
+module.exports = {normalizeRange, readRevisionReport, summarizeRevision};

package/lib/snapshot.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const readAttributes = (attribString, pool, attributes) => {
+  const result = [];
+  for (const number of attributes.decodeAttribString(attribString)) {
+    const pair = pool.getAttrib(number);
+    if (pair) result.push(pair);
+  }
+  return result;
+};
+
+const serializeAText = ({atext, pool, changeset, attributes}) => {
+  const lines = [[]];
+  let offset = 0;
+  for (const op of changeset.deserializeOps(atext.attribs)) {
+    const text = atext.text.slice(offset, offset + op.chars);
+    offset += op.chars;
+    const attrs = readAttributes(op.attribs, pool, attributes);
+    const parts = text.split('\n');
+    for (let index = 0; index < parts.length; index += 1) {
+      if (parts[index]) lines[lines.length - 1].push({text: parts[index], attributes: attrs});
+      if (index < parts.length - 1) lines.push([]);
+    }
+  }
+  if (lines.length && lines[lines.length - 1].length === 0) lines.pop();
+  return lines.map((segments) => ({segments}));
+};
+
+module.exports = {serializeAText};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "ep_bounded_timeslider_api",
+  "version": "0.1.0",
+  "packageManager": "pnpm@11.13.0+sha512.88d94724d8f2e6c186744a5584c6e59ecac869ec7ba15e9cb4cd628e8dc7066820b2481d8ee3b51ea8da323a7378068aa58c556a3720d32b7c20a051d088363a",
+  "description": "Authenticated Etherpad revision analysis and attributed snapshots for assessment workflows.",
+  "author": {
+    "name": "Daniel Castelone",
+    "url": "https://github.com/dcastelone"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcastelone/ep_bounded_timeslider_api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dcastelone/ep_bounded_timeslider_api/issues"
+  },
+  "homepage": "https://github.com/dcastelone/ep_bounded_timeslider_api#readme",
+  "keywords": [
+    "etherpad",
+    "plugin",
+    "assessment",
+    "contributions",
+    "revisions"
+  ],
+  "peerDependencies": {
+    "ep_etherpad-lite": ">=3.3.2 <4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "ep.json",
+    "index.js",
+    "lib/",
+    "static/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "socket": "1.1.143"
+  },
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/static/js/history-authors.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const AUTHORS_ID = 'bounded-timeslider-api-history-authors';
+
+const authorLabel = () => {
+  const html10n = window.html10n;
+  if (html10n && typeof html10n.get === 'function') {
+    return html10n.get('timeslider.toolbar.authors') || 'Authors:';
+  }
+  return 'Authors:';
+};
+
+const ensureAuthorRow = () => {
+  const banner = document.getElementById('history-banner');
+  if (!banner) return null;
+
+  let row = document.getElementById(AUTHORS_ID);
+  if (row) return row;
+
+  row = document.createElement('span');
+  row.id = AUTHORS_ID;
+  row.className = 'timeslider-subtitle';
+  row.setAttribute('aria-live', 'polite');
+
+  const returnButton = document.getElementById('history-banner-return');
+  banner.insertBefore(row, returnButton || null);
+  return row;
+};
+
+const mirrorAuthors = (source) => {
+  const row = ensureAuthorRow();
+  if (!row) return;
+
+  row.replaceChildren();
+  const label = document.createElement('span');
+  label.className = 'authors-label';
+  label.textContent = `${authorLabel()} `;
+  row.appendChild(label);
+  for (const child of source.childNodes) row.appendChild(child.cloneNode(true));
+};
+
+const watchTimeslider = (iframe) => {
+  if (iframe.dataset.boundedTimesliderApiAuthorsBound === 'true') return;
+  iframe.dataset.boundedTimesliderApiAuthorsBound = 'true';
+
+  const bind = () => {
+    let source;
+    try {
+      source = iframe.contentDocument && iframe.contentDocument.getElementById('authorsList');
+    } catch (_err) {
+      return;
+    }
+    if (!source) return;
+    mirrorAuthors(source);
+    new MutationObserver(() => mirrorAuthors(source))
+        .observe(source, {childList: true, subtree: true, characterData: true});
+  };
+
+  iframe.addEventListener('load', bind);
+  bind();
+};
+
+const findTimeslider = () => {
+  const iframe = document.querySelector('#history-frame-mount iframe');
+  if (iframe) watchTimeslider(iframe);
+};
+
+exports.postAceInit = () => {
+  ensureAuthorRow();
+  findTimeslider();
+
+  const mount = document.getElementById('history-frame-mount');
+  if (mount) new MutationObserver(findTimeslider).observe(mount, {childList: true});
+
+  if (window.html10n && typeof window.html10n.bind === 'function') {
+    window.html10n.bind('localized', findTimeslider);
+  }
+};