pi-longhaul 1.0.2 → 1.0.3

package/CHANGELOG.md

@@ -8,6 +8,38 @@ entries and log event types. Rendered state text, prompt wording and section lay
 
 ## [Unreleased]
 
+## [v1.0.3] - 2026-10-22
+
+### Changed
+
+- Tested with pi 1.3.0, now recorded in `pi-compat.json`. No code changes to the extension for it.
+
+### Fixed
+
+- A span's record was lost whenever another extension wrote an entry between pi's compaction and Longhaul's span
+  record. pi-goal does this at every compaction (its `goal-state`, sometimes a `goal-contract` message), active
+  goal or not, so in a session with pi-goal installed most spans folded as narrative-less: the next state kept
+  only the span just closed, and every earlier span's work-log line, Now, decisions, dead ends, objective moves and
+  labelled rules were gone from it. The fold now passes over other extensions' entries until our record arrives; a
+  message, a compaction or one of Longhaul's own event entries arriving first still means the record never
+  landed. The records were always written, so an affected transcript gets its history back at its next
+  compaction. While its records were lost, each pass was shown earlier messages again and recorded their rules
+  again under new ids; with the records back, a rule recorded from the same message in near-duplicate words is
+  one rule, under its newest id, and a lift of any copy lifts it. A rule the user withdrew while its record was
+  lost could not be lifted then (the summarizer did not see it) and comes back now, so look over the
+  constraints the first state after the upgrade shows.
+- Spans whose records were written while earlier records were being lost can carry the same event seqs as an
+  earlier span (each pass numbered from a fold that had lost events). The fold now treats a seq as unique within
+  its span, so those spans fold too; a seq repeated inside one span is still refused as a duplicate. A correction
+  `longhaul_recall` shows as lifted is now the one the lift landed on, never another span's event with the same
+  seq.
+- A replayed event whose span or seq is not a whole number from 1 is refused as malformed. A seq of `1e999`
+  (Infinity) used to be accepted and broke the numbering of every event after it: a `longhaul_remember` write
+  was then stored without a seq and dropped, with no anomaly, when the transcript was read back.
+- The load smoke (`npm run load-smoke`, a development check that is not part of the package) resolved a
+  wildcard `exports` target by replacing only its first `*`; it now replaces every one, as Node does (CodeQL
+  `js/incomplete-sanitization`). No pi package uses a target with two, so the smoke's results are unchanged.
+
 ## [v1.0.2] - 2026-10-13
 
 ### Changed

package/README.md

@@ -361,9 +361,9 @@ listed in [pi-compat.json](pi-compat.json). On a listed line it runs silently. O
 per session and runs; a session that opted out of it (`PI_COMPACTOR=pi`) is not warned. If a compaction fails, pi's own compaction takes over. A nightly job tests against the
 newest pi and opens an issue when it breaks.
 
-Tested with pi 0.87.1, 0.99.0, 0.99.1, 0.99.2, 1.0.0, 1.0.1, 1.0.2, 1.0.3, 1.0.4, 1.1.0 and 1.2.0. Upgrading or
-downgrading pi mid-project is covered too: CI hands one transcript through every listed pi, oldest to newest and
-back, with a Longhaul compaction by each, and each must continue what the others wrote.
+Tested with pi 0.87.1, 0.99.0, 0.99.1, 0.99.2, 1.0.0, 1.0.1, 1.0.2, 1.0.3, 1.0.4, 1.1.0, 1.2.0 and 1.3.0.
+Upgrading or downgrading pi mid-project is covered too: CI hands one transcript through every listed pi, oldest to
+newest and back, with a Longhaul compaction by each, and each must continue what the others wrote.
 
 ## Known issues
 

package/docs/security.md

@@ -39,6 +39,11 @@ extension.
   reading it into memory.
 - A timestamp a `Date` cannot hold is dropped rather than thrown on.
 - An id held by two entries (an old transcript can carry a re-minted id) resolves to the newest holder.
+- A rule recorded again from the message that gave it (near-duplicate words) folds into that rule; a copy of a
+  lifted rule stays lifted, so restored span records cannot bring back a rule the user withdrew from a copy. A lift
+  lands on the rule holding its id now, and on one that held it before only when none does: the store judges the
+  lift against that same rule, and `longhaul_recall` marks lifted what the state lifted.
+- A span or seq that is not a whole number from 1 (`1e999` parses as Infinity) makes the event malformed.
 - An entry from a newer state format is refused by name, so a downgrade starts clean rather than misreading.
 - Learned values read back from a transcript are checked again (length, printable ASCII, count). A name is
   checked as when it was given and dropped if it fails, and a named value must still have a value's shape.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-longhaul",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Keep pi sessions working all night. A compactor that carries your session forward instead of rewriting it: your rules kept in your own words, the state written by code, old reasoning left behind, and about 5x faster than pi's own compaction on a local model.",
   "type": "module",
   "license": "MIT",
@@ -32,7 +32,7 @@
     "extensions": [
       "./src/index.ts"
     ],
-    "image": "https://raw.githubusercontent.com/lobo235/pi-longhaul/v1.0.2/.github/assets/infographic.png"
+    "image": "https://raw.githubusercontent.com/lobo235/pi-longhaul/v1.0.3/.github/assets/infographic.png"
   },
   "files": [
     "src/**/*.ts",
@@ -75,10 +75,10 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.2.0",
-    "@types/node": "^24.19.1",
+    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@types/node": "^24.19.2",
     "typebox": "1.3.7",
-    "typescript": "5.9.3"
+    "typescript": "7.0.2"
   },
   "author": "Justin Barlow"
 }

package/pi-compat.json

@@ -93,6 +93,15 @@
         "npm run smoke and npm run cross-version -- --extra 1.2.0: every listed pi continues 1.2.0's transcripts and it continues theirs",
         "one real compaction through pi --mode rpc on the setup-check fixture with a local model: a compaction record, no fallback"
       ]
+    },
+    {
+      "pi": "1.3.0",
+      "date": "2026-10-16",
+      "how": [
+        "npm test on the vendored pi (the version gate skipped): typecheck, unit suite, load smoke and the extension-API contract checks",
+        "npm run smoke and npm run cross-version -- --extra 1.3.0: every listed pi continues 1.3.0's transcripts and it continues theirs",
+        "one real compaction through pi --mode rpc on the setup-check fixture with a local model: a compaction record, no fallback"
+      ]
     }
   ]
 }

package/src/store/events.ts

@@ -229,10 +229,13 @@ function isEventBody(event: Rec): boolean {
   }
 }
 
+/** A span or seq: a whole number from 1, so a replayed `1e999` (Infinity) cannot stall the numbering after it. */
+const isCount = (value: unknown): value is number => Number.isSafeInteger(value) && (value as number) >= 1;
+
 /** Shape check for replayed entries: a malformed one is skipped and counted by the fold, never thrown. */
 export function isStateEvent(value: unknown): value is StateEvent {
   if (!isRec(value)) return false;
-  const provenanceOk = (value.source === "remember" || value.source === "diff" || value.source === "pass") && typeof value.span === "number" && typeof value.at === "string" && typeof value.seq === "number";
+  const provenanceOk = (value.source === "remember" || value.source === "diff" || value.source === "pass") && isCount(value.span) && typeof value.at === "string" && isCount(value.seq);
   return provenanceOk && isEventBody(value);
 }
 

package/src/store/log.ts

@@ -39,6 +39,7 @@ interface Fold {
   events: StateEvent[];
   spans: SpanSummary[];
   anomalies: FoldAnomaly[];
+  /** `span:seq` of every admitted event: a seq is unique within its span (see seqKey). */
   seqs: Set<string>;
   /** Loose events collected since the last compaction entry, keyed by nothing: in branch order. */
   loose: StateEvent[];
@@ -54,6 +55,15 @@ function quoteOf(event: StateEvent): Quote[] {
   }
 }
 
+/**
+ * The duplicate key of an event: its seq within its span. A pass numbers from the fold it reads, and a fold that
+ * lost span records (another extension's entry ahead of one) numbered later spans from too low a seq, so two
+ * spans' records can share seqs; each span's events are still its own.
+ */
+function seqKey(event: { span: number; seq: number }): string {
+  return `${event.span}:${event.seq}`;
+}
+
 /** Admit one event into the fold, or record why not. */
 function admit(fold: Fold, raw: unknown, span: number, entryId: string, checker: QuoteChecker, into: StateEvent[]): void {
   const newer = newerStateFormat(raw);
@@ -73,7 +83,7 @@ function admit(fold: Fold, raw: unknown, span: number, entryId: string, checker:
     fold.anomalies.push({ span, entryId, reason: `event names span ${raw.span} while folding span ${span}: ${entryId}` });
     return;
   }
-  const key = String(raw.seq);
+  const key = seqKey(raw);
   if (fold.seqs.has(key)) {
     fold.anomalies.push({ span, entryId, reason: `duplicate seq: ${raw.seq} at ${entryId}` });
     return;
@@ -131,7 +141,7 @@ function takeRecord(fold: Fold, entry: Extract<SessionEntry, { type: "custom" }>
   }
   // The record SUPERSEDES the span's loose events, so release their seqs before admitting its own
   // (otherwise the record's authoritative copy of a loose event is dropped as a duplicate seq).
-  for (const loose of fold.loose) fold.seqs.delete(String(loose.seq));
+  for (const loose of fold.loose) fold.seqs.delete(seqKey(loose));
   const events: StateEvent[] = [];
   for (const raw of record.events) admit(fold, raw, pending.span, entry.id, checker, events);
   for (const event of events) fold.events.push(event);
@@ -140,13 +150,23 @@ function takeRecord(fold: Fold, entry: Extract<SessionEntry, { type: "custom" }>
   fold.pending = undefined;
 }
 
+/**
+ * Whether `entry` proves a pending compaction's span record never landed: a message, another compaction, or one
+ * of our own event entries. Anything else another extension wrote at session_compact (pi-goal's goal-state and
+ * goal-contract land there, ahead of the record) is passed over, so the record that follows still closes the span.
+ */
+function endsPendingSpan(entry: SessionEntry): boolean {
+  if (entry.type === "message" || entry.type === "compaction") return true;
+  return entry.type === "custom" && entry.customType === EVENT_ENTRY_TYPE;
+}
+
 export function readLog(branchEntries: SessionEntry[], checker: QuoteChecker): StateLog {
   const fold: Fold = { events: [], spans: [], anomalies: [], seqs: new Set(), loose: [] };
   let compactions = 0;
   for (const entry of branchEntries) {
-    // A pending state compaction is closed by its span record, which is the NEXT entry of interest;
-    // anything else arriving first means the record never landed.
-    if (fold.pending && !(entry.type === "custom" && entry.customType === SPAN_ENTRY_TYPE)) synthesizeClose(fold, undefined, entry.timestamp);
+    // A pending state compaction is closed by its span record, the next entry of OURS after it; a message,
+    // compaction or event arriving first means the record never landed.
+    if (fold.pending && endsPendingSpan(entry)) synthesizeClose(fold, undefined, entry.timestamp);
     if (entry.type === "compaction") {
       compactions++;
       const compactor = compactorOfEntry(entry);

package/src/store/project.ts

@@ -6,6 +6,7 @@
  * Retirement is a projection rule: the log never deletes, and recall reads the log.
  */
 import type { Caps, ForeignCompactor, Now, Quote, Source, StateEvent, StateLog, World } from "./events.ts";
+import { DEFAULT_NEAR_DUPLICATE_THRESHOLD, overlap, tokenize } from "./near-duplicate.ts";
 import { oneLine } from "../one-line.ts";
 
 export interface CorrectionItem {
@@ -17,6 +18,10 @@ export interface CorrectionItem {
   seq: number;
   liftedBy?: { messageId: string; ordinal: string; span: number };
   retired: boolean;
+  /** Ids this rule held before being recorded again from its message (addCorrection); see liftTarget. */
+  formerIds?: Set<string>;
+  /** `span:seq` of the earlier correction.add events folded into this rule, for recall (addCorrection). */
+  copyKeys?: string[];
 }
 
 export interface TextItem {
@@ -108,6 +113,70 @@ function applyClose(state: SessionState, event: Extract<StateEvent, { kind: "spa
   consolidateWorkLog(state, caps);
 }
 
+/**
+ * A rule recorded again from the message that gave it is the same rule: passes that lost their fold's span records
+ * were shown the message again and recorded it again under a new id, sometimes in other words, so a restored log
+ * holds one copy per such span. The rule takes the newest copy's id, span and place, and keeps its older ids for a lift
+ * naming one; a lifted rule stays lifted, as verify.ts keeps it for a new pass.
+ */
+/**
+ * The newest standing or lifted rule `quote` repeats: one from the same message whose words are a near-duplicate
+ * (near-duplicate.ts, at verify's default threshold; two rules one message gave passed that check against each
+ * other when recorded). A rule retired by the cap is not matched, so a later copy brings it back.
+ */
+function sameRuleIndex(corrections: CorrectionItem[], quote: Quote): number {
+  for (let index = corrections.length - 1; index >= 0; index--) {
+    const item = corrections[index];
+    if (item.retired && !item.liftedBy) continue;
+    if (isSameRule(item.quote, quote)) return index;
+  }
+  return -1;
+}
+
+/** Whether two recorded rules are one: the same message, in the same or near-duplicate words. */
+export function isSameRule(a: Quote, b: Quote): boolean {
+  if (a.messageId !== b.messageId) return false;
+  return a.text === b.text || overlap(tokenize(a.text), tokenize(b.text)) >= DEFAULT_NEAR_DUPLICATE_THRESHOLD;
+}
+
+/** An event's key in the log: its seq is unique within its span (log.ts seqKey). */
+export const eventKey = (event: { span: number; seq: number }): string => `${event.span}:${event.seq}`;
+
+/**
+ * The rule a lift naming `target` lands on, for verify.ts, which judges the lift against it, and for the
+ * projection, which applies it, so the two never differ: the newest holder of the id (an old transcript can carry
+ * a reminted one, security.md T1), and only when no rule holds it now, the newest that held it before being
+ * recorded again. A former id another rule holds now names that rule: the lifting pass saw only that one.
+ */
+export function liftTarget(corrections: CorrectionItem[], target: string): CorrectionItem | undefined {
+  return newestWhere(corrections, (item) => item.id === target) ?? newestWhere(corrections, (item) => item.formerIds?.has(target) ?? false);
+}
+
+function newestWhere(corrections: CorrectionItem[], match: (item: CorrectionItem) => boolean): CorrectionItem | undefined {
+  for (let index = corrections.length - 1; index >= 0; index--) if (match(corrections[index])) return corrections[index];
+  return undefined;
+}
+
+function addCorrection(state: SessionState, event: Extract<StateEvent, { kind: "correction.add" }>, caps: Caps): void {
+  state.cursor.R = Math.max(state.cursor.R, idNumber(event.id));
+  const index = sameRuleIndex(state.corrections, event.quote);
+  const earlier = index < 0 ? undefined : state.corrections[index];
+  if (earlier?.liftedBy) {
+    (earlier.copyKeys ??= []).push(eventKey(event));
+    return;
+  }
+  // The new item takes over the earlier one's lists, grown in place: copying them per copy would make N copies of
+  // one rule cost N² (security.md T4).
+  if (earlier) state.corrections.splice(index, 1);
+  const formerIds = earlier?.formerIds ?? new Set<string>();
+  if (earlier) formerIds.add(earlier.id);
+  formerIds.delete(event.id);
+  const copyKeys = earlier?.copyKeys ?? [];
+  if (earlier) copyKeys.push(eventKey(earlier));
+  state.corrections.push({ id: event.id, quote: event.quote, span: event.span, source: event.source, evidence: event.evidence, seq: event.seq, retired: false, ...(formerIds.size ? { formerIds } : {}), ...(copyKeys.length ? { copyKeys } : {}) });
+  state.retired.corrections += retireOverCap(state.corrections, caps.corrections);
+}
+
 export function applyEvent(previous: SessionState, event: StateEvent, caps: Caps): SessionState {
   const state: SessionState = structuredClone(previous);
   applyInPlace(state, event, caps);
@@ -116,7 +185,7 @@ export function applyEvent(previous: SessionState, event: StateEvent, caps: Caps
 
 /** Fold one event into `state`, mutating it. The new state can share objects with the event. */
 function applyInPlace(state: SessionState, event: StateEvent, caps: Caps): void {
-  state.seq = event.seq;
+  state.seq = Math.max(state.seq, event.seq);
   switch (event.kind) {
     case "goal.set":
       state.goal = { quote: event.quote, setSpan: event.span };
@@ -131,15 +200,12 @@ function applyInPlace(state: SessionState, event: StateEvent, caps: Caps): void
       if (state.objective) state.objective.doneWhen = event.quote;
       break;
     case "correction.add":
-      state.corrections.push({ id: event.id, quote: event.quote, span: event.span, source: event.source, evidence: event.evidence, seq: event.seq, retired: false });
-      state.cursor.R = Math.max(state.cursor.R, idNumber(event.id));
-      state.retired.corrections += retireOverCap(state.corrections, caps.corrections);
+      addCorrection(state, event, caps);
       break;
     case "correction.lift": {
-      // Newest first: older transcripts can hold two corrections with one id (a foreign close dropped
-      // the first, the cursor fell back and reminted it; the fold now keeps both). A lift recorded then could only
-      // see the newer one, so the newest holder is the target (security.md T1).
-      const target = [...state.corrections].reverse().find((item) => item.id === event.target);
+      // Older transcripts can hold two corrections with one id (a foreign close dropped the first, the cursor fell
+      // back and reminted it; the fold keeps both): liftTarget picks the one the lifting pass saw.
+      const target = liftTarget(state.corrections, event.target);
       if (target) target.liftedBy = { ...event.by, span: event.span };
       break;
     }

package/src/store/recall.ts

@@ -7,6 +7,7 @@ import type { CommandRecord, ErrorRecord } from "../ledger/handoff.ts";
 import type { Caps, StateEvent, StateLog } from "./events.ts";
 import { orderedFiles } from "../files-render.ts";
 import { oneLine as sanitize } from "../one-line.ts";
+import { eventKey, project } from "./project.ts";
 
 export type RecallWhat = "span" | "commands" | "errors" | "decisions" | "dead-ends" | "corrections" | "message" | "files" | "all";
 
@@ -39,28 +40,31 @@ export interface RecallHit {
 export const RECALL_DEFAULT_LIMIT = 20;
 
 
+/** One projection per recall call, however many kinds it lists (`all`). */
+const liftedKeysCache = new WeakMap<RecallDeps, Set<string>>();
+
 /**
- * The seqs of the corrections a lift landed on, over the WHOLE log (a lift can sit in a later span than its rule).
- * Same rule as the projection: the newest earlier holder of the id, because an older transcript can hold two
- * corrections with one id (security.md T1).
+ * `span:seq` of every correction.add the projection lifted, the copies folded into a lifted rule included, so recall
+ * shows a correction as lifted exactly when the state does (project.ts liftTarget, addCorrection).
  */
-function liftedSeqs(events: StateEvent[]): Set<number> {
-  const seen: Array<{ id: string; seq: number }> = [];
-  const lifted = new Set<number>();
-  for (const event of events) {
-    if (event.kind === "correction.add") seen.push({ id: event.id, seq: event.seq });
-    if (event.kind !== "correction.lift") continue;
-    const target = [...seen].reverse().find((item) => item.id === event.target);
-    if (target) lifted.add(target.seq);
+function liftedKeys(deps: RecallDeps): Set<string> {
+  const cached = liftedKeysCache.get(deps);
+  if (cached) return cached;
+  const keys = new Set<string>();
+  liftedKeysCache.set(deps, keys);
+  for (const item of project(deps.log, deps.caps).corrections) {
+    if (!item.liftedBy) continue;
+    keys.add(eventKey(item));
+    for (const key of item.copyKeys ?? []) keys.add(key);
   }
-  return lifted;
+  return keys;
 }
 
-function itemHits(events: StateEvent[], kind: "decisions" | "dead-ends" | "corrections", lifted: Set<number>): RecallHit[] {
+function itemHits(events: StateEvent[], kind: "decisions" | "dead-ends" | "corrections", lifted: Set<string>): RecallHit[] {
   return events.flatMap((event): RecallHit[] => {
     if (kind === "decisions" && event.kind === "decision.add") return [{ kind, ref: event.id, span: event.span, text: `${event.id} ${sanitize(event.text)}${event.evidence ? ` (${event.evidence})` : ""}` }];
     if (kind === "dead-ends" && event.kind === "deadEnd.add") return [{ kind, ref: event.id, span: event.span, text: `${event.id} ${sanitize(event.text)}${event.evidence ? ` (${event.evidence})` : ""}` }];
-    if (kind === "corrections" && event.kind === "correction.add") return [{ kind, ref: event.id, span: event.span, text: `${event.id} [${event.quote.ordinal}] ${sanitize(event.quote.text)}`, lifted: lifted.has(event.seq) }];
+    if (kind === "corrections" && event.kind === "correction.add") return [{ kind, ref: event.id, span: event.span, text: `${event.id} [${event.quote.ordinal}] ${sanitize(event.quote.text)}`, lifted: lifted.has(eventKey(event)) }];
     return [];
   });
 }
@@ -102,7 +106,7 @@ function spanHits(deps: RecallDeps, span: number): RecallHit[] {
   const record = deps.log.spans.find((summary) => summary.span === span)?.record;
   const commands = (record ? record.ledger.commands.map((c) => ({ ...c, span })) : allCommands(deps).filter((c) => c.span === span)).map(commandHit);
   const errors = (record ? record.ledger.errors.map((e) => ({ ...e, span })) : allErrors(deps).filter((e) => e.span === span)).map(errorHit);
-  const lifted = liftedSeqs(deps.log.events);
+  const lifted = liftedKeys(deps);
   return [head, ...commands, ...errors, ...itemHits(events, "corrections", lifted), ...itemHits(events, "decisions", lifted), ...itemHits(events, "dead-ends", lifted)];
 }
 
@@ -117,7 +121,7 @@ function hitsFor(what: RecallWhat, deps: RecallDeps, query: string | undefined):
     case "span": return query && /^\d+$/.test(query) ? spanHits(deps, Number(query)) : spanHeads(deps);
     case "commands": return allCommands(deps).map(commandHit);
     case "errors": return allErrors(deps).map(errorHit);
-    case "decisions": case "dead-ends": case "corrections": return itemHits(deps.log.events, what, liftedSeqs(deps.log.events));
+    case "decisions": case "dead-ends": case "corrections": return itemHits(deps.log.events, what, liftedKeys(deps));
     case "message": {
       const text = query ? deps.messageText(query) : undefined;
       return text === undefined ? [] : [{ kind: "message", ref: query!, text: sanitize(text) }];

package/src/store/verify.ts

@@ -10,7 +10,7 @@ import { ownRuleOf, withoutReplacedWords } from "./lift-replacement.ts";
 import { liftNamesRule } from "./lift-words.ts";
 import type { Caps, Now, Provenance, Quote, Rejection, StateEvent } from "./events.ts";
 import { findNearDuplicate } from "./near-duplicate.ts";
-import { activeCorrections, activeDeadEnds, activeDecisions, applyEvent, type SessionState } from "./project.ts";
+import { activeCorrections, activeDeadEnds, activeDecisions, applyEvent, liftTarget, type SessionState } from "./project.ts";
 
 export type Proposal =
   | { kind: "objective"; ref?: string; text: string; doneWhen?: { ref?: string; text: string } }
@@ -110,10 +110,10 @@ function verifyQuoteKind(proposal: Extract<Proposal, { kind: "objective" | "done
       return stamp(ctx, undefined, { kind: "correction.add", id: `R${ctx.state.cursor.R + 1}`, quote: resolved.quote });
     }
     case "lift": {
-      // Newest holder of the id, as in project.ts: an old transcript can carry a reminted id (security.md T1). A target
+      // The rule the projection will lift (project.ts liftTarget): an old transcript can carry a reminted id. A target
       // written u<n> names the rule by the message that gave it: a rule labeled in this same pass has no id the model saw.
       const byOrdinal = /^u\d+$/.test(proposal.target);
-      const named = [...ctx.state.corrections].reverse().find((item) => (byOrdinal ? item.quote.ordinal === proposal.target && !item.retired : item.id === proposal.target));
+      const named = byOrdinal ? [...ctx.state.corrections].reverse().find((item) => item.quote.ordinal === proposal.target && !item.retired) : liftTarget(ctx.state.corrections, proposal.target);
       if (!named) return reject({ code: "unknown-target", target: proposal.target, known: activeCorrections(ctx.state).map((item) => item.id) });
       const target = named;
       if (target.liftedBy) {