@playola-radio/slipstream 0.1.0

package/dist/interface-v2-comparison.js

@@ -0,0 +1,135 @@
+/** D3 correspondence and component deltas for interface.v2 written declarations. */
+import { compare, hasDuplicate } from "./interface-projection.js";
+/** v2 D8 excludes the private signature key used by the v1 matcher. */
+function compareV2Rows(a, b) {
+    const rank = { removed: 0, signatureChanged: 1, added: 2 };
+    const byKind = rank[a.kind] - rank[b.kind];
+    if (byKind)
+        return byKind;
+    const cmp = (x, y) => x < y ? -1 : x > y ? 1 : 0;
+    const cmpArray = (x, y) => {
+        for (let i = 0; i < Math.min(x.length, y.length); i++) {
+            const c = cmp(x[i], y[i]);
+            if (c)
+                return c;
+        }
+        return cmp(x.length, y.length);
+    };
+    const compareSide = (x, y, side) => {
+        const left = x[side], right = y[side];
+        if (!left || !right)
+            return left ? 1 : right ? -1 : 0;
+        return cmp(left.display_name, right.display_name)
+            || cmp(x.identity.kind, y.identity.kind)
+            || cmpArray(x.identity.scope.flatMap(scope => [scope.kind, scope.name]), y.identity.scope.flatMap(scope => [scope.kind, scope.name]))
+            || cmp(x.identity.name, y.identity.name)
+            || cmpArray(x.identity.guards, y.identity.guards)
+            || cmp(left.span.byte_start, right.span.byte_start)
+            || cmp(left.span.byte_end, right.span.byte_end);
+    };
+    return compareSide(a, b, a.kind === 'added' ? 'after' : 'before') || compareSide(a, b, 'after');
+}
+function signature(d) {
+    return JSON.stringify([d.role ?? null, d.parameters.map(p => [p.name, p.label, p.binding,
+            p.type, p.optional, p.variadic, p.default, p.modifiers]), d.result, d.throws, d.header]);
+}
+function delta(before, after) {
+    const op = before === null ? 'added' : after === null ? 'removed'
+        : JSON.stringify(before) === JSON.stringify(after) ? 'equal' : 'changed';
+    return { op, before, after };
+}
+function parameterDeltas(before, after) {
+    const counts = (ps) => {
+        const result = new Map();
+        for (const p of ps)
+            if (p.binding === 'identifier')
+                result.set(p.name, (result.get(p.name) ?? 0) + 1);
+        return result;
+    };
+    const beforeCounts = counts(before);
+    const afterCounts = counts(after);
+    const afterByName = new Map(after.map((p, index) => [p.name, index]));
+    const paired = new Set();
+    const rows = before.map(p => {
+        if (p.binding !== 'identifier' || beforeCounts.get(p.name) !== 1 || afterCounts.get(p.name) !== 1) {
+            return delta(p, null);
+        }
+        const index = afterByName.get(p.name);
+        paired.add(index);
+        return delta(p, after[index]);
+    });
+    after.forEach((p, i) => { if (!paired.has(i))
+        rows.push(delta(null, p)); });
+    return rows;
+}
+function outSide(d) {
+    if (!d)
+        return null;
+    return { display_name: d.displayName, span: { byte_start: d.span.byteStart, byte_end: d.span.byteEnd } };
+}
+function toChange(kind, before, after) {
+    const subject = before ?? after;
+    const result = before?.result ?? null;
+    const nextResult = after?.result ?? null;
+    return {
+        kind,
+        identity: subject.identity,
+        before: outSide(before), after: outSide(after),
+        parameters: parameterDeltas(before?.parameters ?? [], after?.parameters ?? []),
+        result: result === null && nextResult === null ? null : delta(result, nextResult),
+        throws: delta(before?.throws ?? null, after?.throws ?? null),
+        header: delta(before?.header ?? null, after?.header ?? null),
+    };
+}
+/** Compare already extracted sides. Endpoint selection and file provenance belong to FD3/FD4. */
+export function compareStructuredExtractions(before, after) {
+    if (before.status === 'incomplete')
+        return {
+            status: 'incomplete', fallback_reason: `before-${before.reason}`, changes: [],
+        };
+    if (after.status === 'incomplete')
+        return {
+            status: 'incomplete', fallback_reason: `after-${after.reason}`, changes: [],
+        };
+    const b = before.status === 'absent' ? [] : before.declarations;
+    const a = after.status === 'absent' ? [] : after.declarations;
+    const asV1 = (d) => ({
+        identity: d.identity, displayName: d.displayName, signature: signature(d), span: d.span,
+    });
+    const beforeV1 = b.map(asV1);
+    const afterV1 = a.map(asV1);
+    if (hasDuplicate(beforeV1) || hasDuplicate(afterV1))
+        return {
+            status: 'incomplete', fallback_reason: 'duplicate-declaration', changes: [],
+        };
+    const matched = compare(beforeV1, afterV1);
+    if (matched.ambiguous)
+        return {
+            status: 'incomplete', fallback_reason: 'ambiguous-correspondence', changes: [],
+        };
+    const lookupKey = (identity, name, signatureText, byteStart, byteEnd) => JSON.stringify([
+        identity.kind, identity.scope, identity.name, identity.guards,
+        name, signatureText, byteStart, byteEnd,
+    ]);
+    const index = (original, converted) => new Map(converted.map((d, i) => [lookupKey(d.identity, d.displayName, d.signature, d.span.byteStart, d.span.byteEnd), original[i]]));
+    const beforeIndex = index(b, beforeV1);
+    const afterIndex = index(a, afterV1);
+    const find = (map, row, identity) => map.get(lookupKey(identity, row.display_name, row.signature, row.span.byte_start, row.span.byte_end)) ?? null;
+    const changes = [];
+    for (const row of matched.changes) {
+        const left = row.before ? find(beforeIndex, row.before, row.identity) : null;
+        const right = row.after ? find(afterIndex, row.after, row.identity) : null;
+        if ((row.before && !left) || (row.after && !right))
+            throw new Error('missing structured declaration');
+        const change = toChange(row.kind, left, right);
+        // Overload role is an internal disambiguator, not a written input/output
+        // component. A role-only transition has no public delta.
+        if (row.kind === 'signatureChanged' && change.parameters.every(p => p.op === 'equal')
+            && (change.result === null || change.result.op === 'equal')
+            && change.throws.op === 'equal' && change.header.op === 'equal')
+            continue;
+        changes.push(change);
+    }
+    changes.sort(compareV2Rows);
+    return { status: 'ready', changes };
+}

package/dist/interface-v2-core.js

@@ -0,0 +1,123 @@
+const identityKey = (d) => JSON.stringify([
+    d.identity.kind, d.identity.scope.map((s) => [s.kind, s.name]), d.identity.name, d.identity.guards,
+]);
+const exactKey = (d) => JSON.stringify([identityKey(d), d.signature]);
+const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function delta(before, after) {
+    return { op: before === null ? 'added' : after === null ? 'removed' : equal(before, after) ? 'equal' : 'changed', before, after };
+}
+function side(d) {
+    return d && { display_name: d.displayName, span: { byte_start: d.span.byteStart, byte_end: d.span.byteEnd } };
+}
+function pairParameters(before, after) {
+    const counts = (ps) => {
+        const result = new Map();
+        for (const p of ps)
+            if (p.binding === 'identifier')
+                result.set(p.name, (result.get(p.name) ?? 0) + 1);
+        return result;
+    };
+    const beforeCount = counts(before), afterCount = counts(after);
+    const usable = (p) => p.binding === 'identifier' && beforeCount.get(p.name) === 1 && afterCount.get(p.name) === 1;
+    const afterByName = new Map(after.filter(usable).map((p) => [p.name, p]));
+    const rows = before.map((p) => delta(p, usable(p) ? afterByName.get(p.name) : null));
+    for (const p of after)
+        if (!usable(p))
+            rows.push(delta(null, p));
+    return rows;
+}
+function row(before, after) {
+    const kind = before === null ? 'added' : after === null ? 'removed' : 'signatureChanged';
+    return {
+        kind, identity: (before ?? after).identity, before: side(before), after: side(after),
+        parameters: pairParameters(before?.parameters ?? [], after?.parameters ?? []),
+        result: (before?.result ?? null) === null && (after?.result ?? null) === null ? null : delta(before?.result ?? null, after?.result ?? null),
+        throws: delta(before?.throws ?? null, after?.throws ?? null),
+        header: delta(before?.header ?? null, after?.header ?? null),
+    };
+}
+function cmp(a, b) { return a < b ? -1 : a > b ? 1 : 0; }
+function cmpArray(a, b) {
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+        const result = cmp(a[i], b[i]);
+        if (result)
+            return result;
+    }
+    return cmp(a.length, b.length);
+}
+/** D8 tuple, adapted to v2's declarationSide (no `signature`: the emitted `before`/`after`
+ * carry only `display_name` and `span`, per contracts/interface/v2/schema.json): display_name,
+ * identity.kind, identity.scope pairs, identity.name, identity.guards, span.byte_start,
+ * span.byte_end. */
+function order(a, b) {
+    const scopeOrder = cmpArray(a.identity.scope.flatMap((s) => [s.kind, s.name]), b.identity.scope.flatMap((s) => [s.kind, s.name]));
+    const guardOrder = cmpArray(a.identity.guards, b.identity.guards);
+    for (const [x, y] of [
+        [a.displayName, b.displayName], [a.identity.kind, b.identity.kind],
+    ]) {
+        const c = cmp(x, y);
+        if (c)
+            return c;
+    }
+    if (scopeOrder)
+        return scopeOrder;
+    const nameOrder = cmp(a.identity.name, b.identity.name);
+    if (nameOrder)
+        return nameOrder;
+    if (guardOrder)
+        return guardOrder;
+    for (const [x, y] of [
+        [a.span.byteStart, b.span.byteStart],
+        [a.span.byteEnd, b.span.byteEnd],
+    ]) {
+        const c = cmp(x, y);
+        if (c)
+            return c;
+    }
+    return 0;
+}
+/** D3 exact-first correspondence, with whole-file refusal for duplicate or ambiguous groups. */
+export function compareV2(before, after) {
+    for (const side of [before, after]) {
+        const keys = side.map(exactKey);
+        if (new Set(keys).size !== keys.length)
+            return { status: 'incomplete', reason: 'duplicate-declaration' };
+    }
+    const beforeExact = new Set(before.map(exactKey)), afterExact = new Set(after.map(exactKey));
+    const groups = new Map();
+    for (const [side, values] of [
+        ['before', before.filter((d) => !afterExact.has(exactKey(d)))],
+        ['after', after.filter((d) => !beforeExact.has(exactKey(d)))],
+    ]) {
+        for (const d of values) {
+            const key = identityKey(d);
+            let group = groups.get(key);
+            if (!group)
+                groups.set(key, group = { before: [], after: [] });
+            group[side].push(d);
+        }
+    }
+    const items = [];
+    for (const group of groups.values()) {
+        const b = group.before, a = group.after;
+        if (b.length && a.length) {
+            if (b.length !== 1 || a.length !== 1)
+                return { status: 'incomplete', reason: 'ambiguous-correspondence' };
+            items.push({ before: b[0], after: a[0] });
+        }
+        else {
+            for (const d of b)
+                items.push({ before: d, after: null });
+            for (const d of a)
+                items.push({ before: null, after: d });
+        }
+    }
+    const rank = { removed: 0, signatureChanged: 1, added: 2 };
+    items.sort((x, y) => {
+        const xKind = x.before === null ? 'added' : x.after === null ? 'removed' : 'signatureChanged';
+        const yKind = y.before === null ? 'added' : y.after === null ? 'removed' : 'signatureChanged';
+        return rank[xKind] - rank[yKind] || order(x.before ?? x.after, y.before ?? y.after) ||
+            (x.after && y.after ? order(x.after, y.after) : 0);
+    });
+    return { status: 'ready', changes: items.map(({ before: b, after: a }) => row(b, a)) };
+}