inngest 4.5.1 → 4.6.0

package/components/execution/otel/aiExtractor.cjs

@@ -0,0 +1,114 @@
+
+//#region src/components/execution/otel/aiExtractor.ts
+/**
+* A `convention` identifies a namespace of AI span attributes and orders which
+* should win when multiple namespaces are present on the same span. Lower
+* numbers override higher numbers.
+*/
+var Convention = /* @__PURE__ */ function(Convention$1) {
+	Convention$1[Convention$1["Semconv"] = 1] = "Semconv";
+	Convention$1[Convention$1["OpenInference"] = 2] = "OpenInference";
+	Convention$1[Convention$1["Vercel"] = 3] = "Vercel";
+	return Convention$1;
+}(Convention || {});
+/**
+* Maps a source attribute key to the canonical {@link AIMetadata} field it
+* populates and the convention it belongs to.
+*/
+const keyFieldMap = {
+	"gen_ai.request.model": {
+		field: "model",
+		convention: Convention.Semconv
+	},
+	"gen_ai.usage.input_tokens": {
+		field: "inputTokens",
+		convention: Convention.Semconv
+	},
+	"llm.model_name": {
+		field: "model",
+		convention: Convention.OpenInference
+	},
+	"llm.token_count.prompt": {
+		field: "inputTokens",
+		convention: Convention.OpenInference
+	},
+	"ai.model.id": {
+		field: "model",
+		convention: Convention.Vercel
+	},
+	"ai.usage.inputTokens": {
+		field: "inputTokens",
+		convention: Convention.Vercel
+	},
+	"ai.usage.tokens": {
+		field: "inputTokens",
+		convention: Convention.Vercel
+	}
+};
+/**
+* Extracts AI model metadata from a span's attributes.
+*
+* Attributes are matched across multiple instrumentation conventions
+* (OpenTelemetry semconv, OpenInference, Vercel AI SDK). When more than one
+* convention supplies the same field, the highest-precedence value wins.
+*
+* @param attributes - The span attributes, as exposed by
+* `ReadableSpan.attributes`.
+*/
+const extractAIMetadataFromAttributes = (attributes) => {
+	const candidates = {};
+	for (const [key, value] of Object.entries(attributes)) {
+		if (value === void 0) continue;
+		const mapping = keyFieldMap[key];
+		if (!mapping) continue;
+		const existing = candidates[mapping.field];
+		if (!existing || mapping.convention < existing.convention) candidates[mapping.field] = {
+			value,
+			convention: mapping.convention
+		};
+	}
+	const metadata = {};
+	const model = candidates.model?.value;
+	if (typeof model === "string" && model !== "") metadata.model = model;
+	const inputTokens = candidates.inputTokens?.value;
+	if (inputTokens !== void 0) {
+		const n = Number(inputTokens);
+		if (!Number.isNaN(n)) metadata.inputTokens = n;
+	}
+	return metadata;
+};
+/**
+* Aggregates two {@link AIMetadata} values into one.
+*
+* Input token counts are summed, while `a`'s model takes precedence over `b`'s.
+* Each field is only present in the result when at least one input supplies it.
+*
+* @param a - The primary metadata; its `model` wins when both are present.
+* @param b - The secondary metadata.
+*/
+const aggregate = (a, b) => {
+	const metadata = {};
+	const model = a.model ?? b.model;
+	if (model !== void 0) metadata.model = model;
+	if (a.inputTokens !== void 0 || b.inputTokens !== void 0) metadata.inputTokens = (a.inputTokens ?? 0) + (b.inputTokens ?? 0);
+	return metadata;
+};
+/**
+* Maps an {@link AIMetadata} value onto the server's `inngest.ai` metadata
+* schema (snake_case keys). Only the fields we extract are emitted; absent
+* fields are omitted rather than zero-valued. Returns `undefined` when there
+* is nothing to emit, so callers can skip stamping metadata entirely.
+*/
+const toInngestAIMetadataValues = (metadata) => {
+	const values = {};
+	if (metadata.model !== void 0) values.model = metadata.model;
+	if (metadata.inputTokens !== void 0) values.input_tokens = metadata.inputTokens;
+	if (Object.keys(values).length === 0) return;
+	return values;
+};
+
+//#endregion
+exports.aggregate = aggregate;
+exports.extractAIMetadataFromAttributes = extractAIMetadataFromAttributes;
+exports.toInngestAIMetadataValues = toInngestAIMetadataValues;
+//# sourceMappingURL=aiExtractor.cjs.map

package/components/execution/otel/aiExtractor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiExtractor.cjs","names":["keyFieldMap: Record<string, Mapping>","candidates: Partial<Record<Field, Candidate>>","metadata: AIMetadata","values: Record<string, unknown>"],"sources":["../../../../src/components/execution/otel/aiExtractor.ts"],"sourcesContent":["import type { Attributes, AttributeValue } from \"@opentelemetry/api\";\n\n/**\n * AI metadata extracted from a span's attributes.\n *\n * A field is only present when a matching attribute was found on the span;\n * absent fields are omitted rather than zero-valued.\n */\nexport interface AIMetadata {\n  /** The requested model, e.g. `gpt-4.1-nano`. */\n  model?: string;\n  /** The number of input (prompt) tokens consumed by the request. */\n  inputTokens?: number;\n}\n\n/**\n * A `convention` identifies a namespace of AI span attributes and orders which\n * should win when multiple namespaces are present on the same span. Lower\n * numbers override higher numbers.\n */\nenum Convention {\n  Semconv = 1,\n  OpenInference = 2,\n  Vercel = 3,\n}\n\ntype Field = keyof AIMetadata;\n\ninterface Mapping {\n  field: Field;\n  convention: Convention;\n}\n\n/**\n * Maps a source attribute key to the canonical {@link AIMetadata} field it\n * populates and the convention it belongs to.\n */\nconst keyFieldMap: Record<string, Mapping> = {\n  // OpenTelemetry Semantic Conventions\n  \"gen_ai.request.model\": { field: \"model\", convention: Convention.Semconv },\n  \"gen_ai.usage.input_tokens\": {\n    field: \"inputTokens\",\n    convention: Convention.Semconv,\n  },\n\n  // OpenInference\n  \"llm.model_name\": { field: \"model\", convention: Convention.OpenInference },\n  \"llm.token_count.prompt\": {\n    field: \"inputTokens\",\n    convention: Convention.OpenInference,\n  },\n\n  // Vercel AI SDK (native `ai.*` telemetry)\n  \"ai.model.id\": { field: \"model\", convention: Convention.Vercel },\n  \"ai.usage.inputTokens\": {\n    field: \"inputTokens\",\n    convention: Convention.Vercel,\n  },\n  // Embeddings spans emit only a single `ai.usage.tokens` count (no\n  // input/output split); map it to inputTokens to match the semconv embeddings\n  // case.\n  \"ai.usage.tokens\": { field: \"inputTokens\", convention: Convention.Vercel },\n};\n\ninterface Candidate {\n  value: AttributeValue;\n  convention: Convention;\n}\n\n/**\n * Extracts AI model metadata from a span's attributes.\n *\n * Attributes are matched across multiple instrumentation conventions\n * (OpenTelemetry semconv, OpenInference, Vercel AI SDK). When more than one\n * convention supplies the same field, the highest-precedence value wins.\n *\n * @param attributes - The span attributes, as exposed by\n * `ReadableSpan.attributes`.\n */\nexport const extractAIMetadataFromAttributes = (\n  attributes: Attributes,\n): AIMetadata => {\n  // Track the highest-precedence (lowest convention) candidate seen per field.\n  const candidates: Partial<Record<Field, Candidate>> = {};\n\n  for (const [key, value] of Object.entries(attributes)) {\n    if (value === undefined) {\n      continue;\n    }\n\n    const mapping = keyFieldMap[key];\n    if (!mapping) {\n      continue;\n    }\n\n    const existing = candidates[mapping.field];\n    if (!existing || mapping.convention < existing.convention) {\n      candidates[mapping.field] = { value, convention: mapping.convention };\n    }\n  }\n\n  const metadata: AIMetadata = {};\n\n  const model = candidates.model?.value;\n  if (typeof model === \"string\" && model !== \"\") {\n    metadata.model = model;\n  }\n\n  const inputTokens = candidates.inputTokens?.value;\n  if (inputTokens !== undefined) {\n    // Token counts arrive as numbers from the SDK, but OTLP/JSON encodes int64\n    // as either a number or a quoted string, so coerce defensively.\n    const n = Number(inputTokens);\n    if (!Number.isNaN(n)) {\n      metadata.inputTokens = n;\n    }\n  }\n\n  return metadata;\n};\n\n/**\n * Aggregates two {@link AIMetadata} values into one.\n *\n * Input token counts are summed, while `a`'s model takes precedence over `b`'s.\n * Each field is only present in the result when at least one input supplies it.\n *\n * @param a - The primary metadata; its `model` wins when both are present.\n * @param b - The secondary metadata.\n */\nexport const aggregate = (a: AIMetadata, b: AIMetadata): AIMetadata => {\n  const metadata: AIMetadata = {};\n\n  const model = a.model ?? b.model;\n  if (model !== undefined) {\n    metadata.model = model;\n  }\n\n  if (a.inputTokens !== undefined || b.inputTokens !== undefined) {\n    metadata.inputTokens = (a.inputTokens ?? 0) + (b.inputTokens ?? 0);\n  }\n\n  return metadata;\n};\n\n/**\n * Maps an {@link AIMetadata} value onto the server's `inngest.ai` metadata\n * schema (snake_case keys). Only the fields we extract are emitted; absent\n * fields are omitted rather than zero-valued. Returns `undefined` when there\n * is nothing to emit, so callers can skip stamping metadata entirely.\n */\nexport const toInngestAIMetadataValues = (\n  metadata: AIMetadata,\n): Record<string, unknown> | undefined => {\n  const values: Record<string, unknown> = {};\n\n  if (metadata.model !== undefined) {\n    values.model = metadata.model;\n  }\n\n  if (metadata.inputTokens !== undefined) {\n    values.input_tokens = metadata.inputTokens;\n  }\n\n  if (Object.keys(values).length === 0) {\n    return undefined;\n  }\n\n  return values;\n};\n"],"mappings":";;;;;;;AAoBA,IAAK,oDAAL;AACE;AACA;AACA;;EAHG;;;;;AAiBL,MAAMA,cAAuC;CAE3C,wBAAwB;EAAE,OAAO;EAAS,YAAY,WAAW;EAAS;CAC1E,6BAA6B;EAC3B,OAAO;EACP,YAAY,WAAW;EACxB;CAGD,kBAAkB;EAAE,OAAO;EAAS,YAAY,WAAW;EAAe;CAC1E,0BAA0B;EACxB,OAAO;EACP,YAAY,WAAW;EACxB;CAGD,eAAe;EAAE,OAAO;EAAS,YAAY,WAAW;EAAQ;CAChE,wBAAwB;EACtB,OAAO;EACP,YAAY,WAAW;EACxB;CAID,mBAAmB;EAAE,OAAO;EAAe,YAAY,WAAW;EAAQ;CAC3E;;;;;;;;;;;AAiBD,MAAa,mCACX,eACe;CAEf,MAAMC,aAAgD,EAAE;AAExD,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,WAAW,EAAE;AACrD,MAAI,UAAU,OACZ;EAGF,MAAM,UAAU,YAAY;AAC5B,MAAI,CAAC,QACH;EAGF,MAAM,WAAW,WAAW,QAAQ;AACpC,MAAI,CAAC,YAAY,QAAQ,aAAa,SAAS,WAC7C,YAAW,QAAQ,SAAS;GAAE;GAAO,YAAY,QAAQ;GAAY;;CAIzE,MAAMC,WAAuB,EAAE;CAE/B,MAAM,QAAQ,WAAW,OAAO;AAChC,KAAI,OAAO,UAAU,YAAY,UAAU,GACzC,UAAS,QAAQ;CAGnB,MAAM,cAAc,WAAW,aAAa;AAC5C,KAAI,gBAAgB,QAAW;EAG7B,MAAM,IAAI,OAAO,YAAY;AAC7B,MAAI,CAAC,OAAO,MAAM,EAAE,CAClB,UAAS,cAAc;;AAI3B,QAAO;;;;;;;;;;;AAYT,MAAa,aAAa,GAAe,MAA8B;CACrE,MAAMA,WAAuB,EAAE;CAE/B,MAAM,QAAQ,EAAE,SAAS,EAAE;AAC3B,KAAI,UAAU,OACZ,UAAS,QAAQ;AAGnB,KAAI,EAAE,gBAAgB,UAAa,EAAE,gBAAgB,OACnD,UAAS,eAAe,EAAE,eAAe,MAAM,EAAE,eAAe;AAGlE,QAAO;;;;;;;;AAST,MAAa,6BACX,aACwC;CACxC,MAAMC,SAAkC,EAAE;AAE1C,KAAI,SAAS,UAAU,OACrB,QAAO,QAAQ,SAAS;AAG1B,KAAI,SAAS,gBAAgB,OAC3B,QAAO,eAAe,SAAS;AAGjC,KAAI,OAAO,KAAK,OAAO,CAAC,WAAW,EACjC;AAGF,QAAO"}

package/components/execution/otel/aiExtractor.d.cts

@@ -0,0 +1,16 @@
+//#region src/components/execution/otel/aiExtractor.d.ts
+/**
+ * AI metadata extracted from a span's attributes.
+ *
+ * A field is only present when a matching attribute was found on the span;
+ * absent fields are omitted rather than zero-valued.
+ */
+interface AIMetadata {
+  /** The requested model, e.g. `gpt-4.1-nano`. */
+  model?: string;
+  /** The number of input (prompt) tokens consumed by the request. */
+  inputTokens?: number;
+}
+//#endregion
+export { AIMetadata };
+//# sourceMappingURL=aiExtractor.d.cts.map

package/components/execution/otel/aiExtractor.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiExtractor.d.cts","names":[],"sources":["../../../../src/components/execution/otel/aiExtractor.ts"],"sourcesContent":[],"mappings":";AAQA;;;;;;UAAiB,UAAA"}

package/components/execution/otel/aiExtractor.d.ts

@@ -0,0 +1,19 @@
+import "@opentelemetry/api";
+
+//#region src/components/execution/otel/aiExtractor.d.ts
+
+/**
+ * AI metadata extracted from a span's attributes.
+ *
+ * A field is only present when a matching attribute was found on the span;
+ * absent fields are omitted rather than zero-valued.
+ */
+interface AIMetadata {
+  /** The requested model, e.g. `gpt-4.1-nano`. */
+  model?: string;
+  /** The number of input (prompt) tokens consumed by the request. */
+  inputTokens?: number;
+}
+//#endregion
+export { AIMetadata };
+//# sourceMappingURL=aiExtractor.d.ts.map

package/components/execution/otel/aiExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiExtractor.d.ts","names":[],"sources":["../../../../src/components/execution/otel/aiExtractor.ts"],"sourcesContent":[],"mappings":";;;;;;AAQA;;;;UAAiB,UAAA"}

package/components/execution/otel/aiExtractor.js

@@ -0,0 +1,111 @@
+//#region src/components/execution/otel/aiExtractor.ts
+/**
+* A `convention` identifies a namespace of AI span attributes and orders which
+* should win when multiple namespaces are present on the same span. Lower
+* numbers override higher numbers.
+*/
+var Convention = /* @__PURE__ */ function(Convention$1) {
+	Convention$1[Convention$1["Semconv"] = 1] = "Semconv";
+	Convention$1[Convention$1["OpenInference"] = 2] = "OpenInference";
+	Convention$1[Convention$1["Vercel"] = 3] = "Vercel";
+	return Convention$1;
+}(Convention || {});
+/**
+* Maps a source attribute key to the canonical {@link AIMetadata} field it
+* populates and the convention it belongs to.
+*/
+const keyFieldMap = {
+	"gen_ai.request.model": {
+		field: "model",
+		convention: Convention.Semconv
+	},
+	"gen_ai.usage.input_tokens": {
+		field: "inputTokens",
+		convention: Convention.Semconv
+	},
+	"llm.model_name": {
+		field: "model",
+		convention: Convention.OpenInference
+	},
+	"llm.token_count.prompt": {
+		field: "inputTokens",
+		convention: Convention.OpenInference
+	},
+	"ai.model.id": {
+		field: "model",
+		convention: Convention.Vercel
+	},
+	"ai.usage.inputTokens": {
+		field: "inputTokens",
+		convention: Convention.Vercel
+	},
+	"ai.usage.tokens": {
+		field: "inputTokens",
+		convention: Convention.Vercel
+	}
+};
+/**
+* Extracts AI model metadata from a span's attributes.
+*
+* Attributes are matched across multiple instrumentation conventions
+* (OpenTelemetry semconv, OpenInference, Vercel AI SDK). When more than one
+* convention supplies the same field, the highest-precedence value wins.
+*
+* @param attributes - The span attributes, as exposed by
+* `ReadableSpan.attributes`.
+*/
+const extractAIMetadataFromAttributes = (attributes) => {
+	const candidates = {};
+	for (const [key, value] of Object.entries(attributes)) {
+		if (value === void 0) continue;
+		const mapping = keyFieldMap[key];
+		if (!mapping) continue;
+		const existing = candidates[mapping.field];
+		if (!existing || mapping.convention < existing.convention) candidates[mapping.field] = {
+			value,
+			convention: mapping.convention
+		};
+	}
+	const metadata = {};
+	const model = candidates.model?.value;
+	if (typeof model === "string" && model !== "") metadata.model = model;
+	const inputTokens = candidates.inputTokens?.value;
+	if (inputTokens !== void 0) {
+		const n = Number(inputTokens);
+		if (!Number.isNaN(n)) metadata.inputTokens = n;
+	}
+	return metadata;
+};
+/**
+* Aggregates two {@link AIMetadata} values into one.
+*
+* Input token counts are summed, while `a`'s model takes precedence over `b`'s.
+* Each field is only present in the result when at least one input supplies it.
+*
+* @param a - The primary metadata; its `model` wins when both are present.
+* @param b - The secondary metadata.
+*/
+const aggregate = (a, b) => {
+	const metadata = {};
+	const model = a.model ?? b.model;
+	if (model !== void 0) metadata.model = model;
+	if (a.inputTokens !== void 0 || b.inputTokens !== void 0) metadata.inputTokens = (a.inputTokens ?? 0) + (b.inputTokens ?? 0);
+	return metadata;
+};
+/**
+* Maps an {@link AIMetadata} value onto the server's `inngest.ai` metadata
+* schema (snake_case keys). Only the fields we extract are emitted; absent
+* fields are omitted rather than zero-valued. Returns `undefined` when there
+* is nothing to emit, so callers can skip stamping metadata entirely.
+*/
+const toInngestAIMetadataValues = (metadata) => {
+	const values = {};
+	if (metadata.model !== void 0) values.model = metadata.model;
+	if (metadata.inputTokens !== void 0) values.input_tokens = metadata.inputTokens;
+	if (Object.keys(values).length === 0) return;
+	return values;
+};
+
+//#endregion
+export { aggregate, extractAIMetadataFromAttributes, toInngestAIMetadataValues };
+//# sourceMappingURL=aiExtractor.js.map

package/components/execution/otel/aiExtractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiExtractor.js","names":["keyFieldMap: Record<string, Mapping>","candidates: Partial<Record<Field, Candidate>>","metadata: AIMetadata","values: Record<string, unknown>"],"sources":["../../../../src/components/execution/otel/aiExtractor.ts"],"sourcesContent":["import type { Attributes, AttributeValue } from \"@opentelemetry/api\";\n\n/**\n * AI metadata extracted from a span's attributes.\n *\n * A field is only present when a matching attribute was found on the span;\n * absent fields are omitted rather than zero-valued.\n */\nexport interface AIMetadata {\n  /** The requested model, e.g. `gpt-4.1-nano`. */\n  model?: string;\n  /** The number of input (prompt) tokens consumed by the request. */\n  inputTokens?: number;\n}\n\n/**\n * A `convention` identifies a namespace of AI span attributes and orders which\n * should win when multiple namespaces are present on the same span. Lower\n * numbers override higher numbers.\n */\nenum Convention {\n  Semconv = 1,\n  OpenInference = 2,\n  Vercel = 3,\n}\n\ntype Field = keyof AIMetadata;\n\ninterface Mapping {\n  field: Field;\n  convention: Convention;\n}\n\n/**\n * Maps a source attribute key to the canonical {@link AIMetadata} field it\n * populates and the convention it belongs to.\n */\nconst keyFieldMap: Record<string, Mapping> = {\n  // OpenTelemetry Semantic Conventions\n  \"gen_ai.request.model\": { field: \"model\", convention: Convention.Semconv },\n  \"gen_ai.usage.input_tokens\": {\n    field: \"inputTokens\",\n    convention: Convention.Semconv,\n  },\n\n  // OpenInference\n  \"llm.model_name\": { field: \"model\", convention: Convention.OpenInference },\n  \"llm.token_count.prompt\": {\n    field: \"inputTokens\",\n    convention: Convention.OpenInference,\n  },\n\n  // Vercel AI SDK (native `ai.*` telemetry)\n  \"ai.model.id\": { field: \"model\", convention: Convention.Vercel },\n  \"ai.usage.inputTokens\": {\n    field: \"inputTokens\",\n    convention: Convention.Vercel,\n  },\n  // Embeddings spans emit only a single `ai.usage.tokens` count (no\n  // input/output split); map it to inputTokens to match the semconv embeddings\n  // case.\n  \"ai.usage.tokens\": { field: \"inputTokens\", convention: Convention.Vercel },\n};\n\ninterface Candidate {\n  value: AttributeValue;\n  convention: Convention;\n}\n\n/**\n * Extracts AI model metadata from a span's attributes.\n *\n * Attributes are matched across multiple instrumentation conventions\n * (OpenTelemetry semconv, OpenInference, Vercel AI SDK). When more than one\n * convention supplies the same field, the highest-precedence value wins.\n *\n * @param attributes - The span attributes, as exposed by\n * `ReadableSpan.attributes`.\n */\nexport const extractAIMetadataFromAttributes = (\n  attributes: Attributes,\n): AIMetadata => {\n  // Track the highest-precedence (lowest convention) candidate seen per field.\n  const candidates: Partial<Record<Field, Candidate>> = {};\n\n  for (const [key, value] of Object.entries(attributes)) {\n    if (value === undefined) {\n      continue;\n    }\n\n    const mapping = keyFieldMap[key];\n    if (!mapping) {\n      continue;\n    }\n\n    const existing = candidates[mapping.field];\n    if (!existing || mapping.convention < existing.convention) {\n      candidates[mapping.field] = { value, convention: mapping.convention };\n    }\n  }\n\n  const metadata: AIMetadata = {};\n\n  const model = candidates.model?.value;\n  if (typeof model === \"string\" && model !== \"\") {\n    metadata.model = model;\n  }\n\n  const inputTokens = candidates.inputTokens?.value;\n  if (inputTokens !== undefined) {\n    // Token counts arrive as numbers from the SDK, but OTLP/JSON encodes int64\n    // as either a number or a quoted string, so coerce defensively.\n    const n = Number(inputTokens);\n    if (!Number.isNaN(n)) {\n      metadata.inputTokens = n;\n    }\n  }\n\n  return metadata;\n};\n\n/**\n * Aggregates two {@link AIMetadata} values into one.\n *\n * Input token counts are summed, while `a`'s model takes precedence over `b`'s.\n * Each field is only present in the result when at least one input supplies it.\n *\n * @param a - The primary metadata; its `model` wins when both are present.\n * @param b - The secondary metadata.\n */\nexport const aggregate = (a: AIMetadata, b: AIMetadata): AIMetadata => {\n  const metadata: AIMetadata = {};\n\n  const model = a.model ?? b.model;\n  if (model !== undefined) {\n    metadata.model = model;\n  }\n\n  if (a.inputTokens !== undefined || b.inputTokens !== undefined) {\n    metadata.inputTokens = (a.inputTokens ?? 0) + (b.inputTokens ?? 0);\n  }\n\n  return metadata;\n};\n\n/**\n * Maps an {@link AIMetadata} value onto the server's `inngest.ai` metadata\n * schema (snake_case keys). Only the fields we extract are emitted; absent\n * fields are omitted rather than zero-valued. Returns `undefined` when there\n * is nothing to emit, so callers can skip stamping metadata entirely.\n */\nexport const toInngestAIMetadataValues = (\n  metadata: AIMetadata,\n): Record<string, unknown> | undefined => {\n  const values: Record<string, unknown> = {};\n\n  if (metadata.model !== undefined) {\n    values.model = metadata.model;\n  }\n\n  if (metadata.inputTokens !== undefined) {\n    values.input_tokens = metadata.inputTokens;\n  }\n\n  if (Object.keys(values).length === 0) {\n    return undefined;\n  }\n\n  return values;\n};\n"],"mappings":";;;;;;AAoBA,IAAK,oDAAL;AACE;AACA;AACA;;EAHG;;;;;AAiBL,MAAMA,cAAuC;CAE3C,wBAAwB;EAAE,OAAO;EAAS,YAAY,WAAW;EAAS;CAC1E,6BAA6B;EAC3B,OAAO;EACP,YAAY,WAAW;EACxB;CAGD,kBAAkB;EAAE,OAAO;EAAS,YAAY,WAAW;EAAe;CAC1E,0BAA0B;EACxB,OAAO;EACP,YAAY,WAAW;EACxB;CAGD,eAAe;EAAE,OAAO;EAAS,YAAY,WAAW;EAAQ;CAChE,wBAAwB;EACtB,OAAO;EACP,YAAY,WAAW;EACxB;CAID,mBAAmB;EAAE,OAAO;EAAe,YAAY,WAAW;EAAQ;CAC3E;;;;;;;;;;;AAiBD,MAAa,mCACX,eACe;CAEf,MAAMC,aAAgD,EAAE;AAExD,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,WAAW,EAAE;AACrD,MAAI,UAAU,OACZ;EAGF,MAAM,UAAU,YAAY;AAC5B,MAAI,CAAC,QACH;EAGF,MAAM,WAAW,WAAW,QAAQ;AACpC,MAAI,CAAC,YAAY,QAAQ,aAAa,SAAS,WAC7C,YAAW,QAAQ,SAAS;GAAE;GAAO,YAAY,QAAQ;GAAY;;CAIzE,MAAMC,WAAuB,EAAE;CAE/B,MAAM,QAAQ,WAAW,OAAO;AAChC,KAAI,OAAO,UAAU,YAAY,UAAU,GACzC,UAAS,QAAQ;CAGnB,MAAM,cAAc,WAAW,aAAa;AAC5C,KAAI,gBAAgB,QAAW;EAG7B,MAAM,IAAI,OAAO,YAAY;AAC7B,MAAI,CAAC,OAAO,MAAM,EAAE,CAClB,UAAS,cAAc;;AAI3B,QAAO;;;;;;;;;;;AAYT,MAAa,aAAa,GAAe,MAA8B;CACrE,MAAMA,WAAuB,EAAE;CAE/B,MAAM,QAAQ,EAAE,SAAS,EAAE;AAC3B,KAAI,UAAU,OACZ,UAAS,QAAQ;AAGnB,KAAI,EAAE,gBAAgB,UAAa,EAAE,gBAAgB,OACnD,UAAS,eAAe,EAAE,eAAe,MAAM,EAAE,eAAe;AAGlE,QAAO;;;;;;;;AAST,MAAa,6BACX,aACwC;CACxC,MAAMC,SAAkC,EAAE;AAE1C,KAAI,SAAS,UAAU,OACrB,QAAO,QAAQ,SAAS;AAG1B,KAAI,SAAS,gBAAgB,OAC3B,QAAO,eAAe,SAAS;AAGjC,KAAI,OAAO,KAAK,OAAO,CAAC,WAAW,EACjC;AAGF,QAAO"}

package/components/execution/otel/metadataProcessor.cjs

@@ -0,0 +1,195 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_types = require('../../../helpers/types.cjs');
+const require_aiExtractor = require('./aiExtractor.cjs');
+const require_consts = require('./consts.cjs');
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let __opentelemetry_api = require("@opentelemetry/api");
+
+//#region src/components/execution/otel/metadataProcessor.ts
+const processorDevDebug = (0, debug.default)(`${require_consts.debugPrefix}:InngestMetadataSpanProcessor`);
+/**
+* Resolve the currently-registered global OTel tracer provider, unwrapping
+* the `ProxyTracerProvider` wrapper that `trace.getTracerProvider()` returns.
+* Returns `undefined` when no provider is registered.
+*/
+const getGlobalProvider = () => {
+	const globalProvider = __opentelemetry_api.trace.getTracerProvider();
+	if (!globalProvider) return;
+	return ("getDelegate" in globalProvider && typeof globalProvider.getDelegate === "function" ? globalProvider.getDelegate() : globalProvider) ?? void 0;
+};
+/**
+* Attempts to add the given span processor to the given OTel provider.
+* Returns `true` if the processor was attached, `false` if the provider could
+* not be extended.
+*
+* It handles both OTel SDK v1 (`addSpanProcessor()`) and v2 (internal
+* `_spanProcessors` array).
+*
+* This intentionally duplicates the attach logic inside `extendProvider`
+* (`util.ts`) to avoid imports with instrumentation side effects.
+*/
+const attachToProvider = (provider, processor) => {
+	if ("addSpanProcessor" in provider && typeof provider.addSpanProcessor === "function") {
+		provider.addSpanProcessor(processor);
+		return true;
+	}
+	const spanProcessors = getInternalSpanProcessors(provider);
+	if (spanProcessors) {
+		spanProcessors.push(processor);
+		return true;
+	}
+	return false;
+};
+/**
+* Extract the internal span processors array from a BasicTracerProvider.
+* Returns the mutable array if accessible, undefined otherwise.
+*
+* BasicTracerProvider._activeSpanProcessor is a MultiSpanProcessor,
+* which holds a _spanProcessors: SpanProcessor[] array.
+* Both are TypeScript `private` (not ES #private), so accessible at runtime.
+*
+* Wrapped in try/catch because this accesses internal OTel fields that may
+* change — must never crash the host app.
+*/
+function getInternalSpanProcessors(provider) {
+	if (!require_types.isRecord(provider)) return;
+	try {
+		const active = provider._activeSpanProcessor;
+		if (!require_types.isRecord(active)) return void 0;
+		const arr = active._spanProcessors;
+		return Array.isArray(arr) ? arr : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Builds the `#spanSinks` key for a span. Span IDs are only guaranteed unique
+* within a single trace, so spans are keyed by trace ID + span ID to avoid
+* cross-trace collisions.
+*/
+const spanSinkKey = (traceId, spanId) => `${traceId}:${spanId}`;
+/**
+* A read-only OTel span processor that is independent of the Extended Traces
+* processor (`InngestSpanProcessor`).
+*
+* It tracks which spans belong to an Inngest step (seeded by
+* {@link declareStartingSpan} and passed from parent to child in `onStart`).
+*
+* When a tracked span ends, it extracts {@link AIMetadata} from the span's
+* attributes and pushes it to the span's {@link AIMetadataSink}.
+*/
+var InngestMetadataSpanProcessor = class {
+	/**
+	* A map of tracked spans to their sink.
+	*
+	* We use traceId:spanID as the key, which uniquely identifies each span. See
+	* {@link spanSinkKey}
+	*
+	* The engine seeds the map during {@link declareStartingSpan} with the root
+	* span and its sink.
+	*
+	* During onStart, the processor looks up the span's parent's sink and then
+	* records the span as also using that sink. If the parent is not found, then
+	* the span is not descended from a root step span, and therefore does not
+	* need to have a sink.
+	*
+	* All spans with the same root span that started the step will share the
+	* same sink.
+	*/
+	#spanSinks = /* @__PURE__ */ new Map();
+	/**
+	* A registry used to clean up items from `#spanSinks` when spans fall out of
+	* reference without ending. Avoids leaking entries (and the engine sink
+	* closures they reference) for spans that are never ended and are GC'd.
+	*/
+	#spanCleanup = new FinalizationRegistry((key) => {
+		if (key) this.#spanSinks.delete(key);
+	});
+	/**
+	* Latches once this processor has been attached to a global OTel provider, so
+	* {@link attach} can never push it into a provider's processor list twice
+	* (which would double-process every span and double-count tokens).
+	*/
+	#attached = false;
+	/**
+	* Idempotently attach this processor to the global OTel provider that already
+	* exists, so it begins receiving span lifecycle events.
+	*/
+	attach() {
+		if (this.#attached) return;
+		const provider = getGlobalProvider();
+		if (!provider) return;
+		if (attachToProvider(provider, this)) {
+			this.#attached = true;
+			processorDevDebug("attached to global OTel provider");
+		}
+	}
+	/**
+	* Declare the step's root span. Seeds tracking so that the root and all of
+	* its descendants share the same AIMetadata sink.
+	*/
+	declareStartingSpan({ span, traceparent, onAIMetadata }) {
+		if (!this.#attached) return;
+		if (!traceparent) return processorDevDebug("no traceparent found for span", span.spanContext().spanId, "so skipping it");
+		this.trackSpan(span, onAIMetadata);
+	}
+	/**
+	* Mark a span as tracked, recording its step's sink and registering it for
+	* cleanup.
+	*
+	* Read-only: unlike the Extended Traces processor, no attributes
+	* are stamped on the span.
+	*/
+	trackSpan(span, sink) {
+		const { traceId, spanId } = span.spanContext();
+		const key = spanSinkKey(traceId, spanId);
+		this.#spanCleanup.register(span, key, span);
+		this.#spanSinks.set(key, sink);
+	}
+	/**
+	* Clean up references to a span that has ended (or been GC'd).
+	*/
+	cleanupSpan(span) {
+		const { traceId, spanId } = span.spanContext();
+		this.#spanCleanup.unregister(span);
+		this.#spanSinks.delete(spanSinkKey(traceId, spanId));
+	}
+	/**
+	* Track children of spans we already care about, so the whole subtree under a
+	* declared root is captured.
+	*/
+	onStart(span, parentContext) {
+		const parentSpanId = __opentelemetry_api.trace.getSpanContext(parentContext)?.spanId;
+		if (!parentSpanId) return;
+		const sink = this.#spanSinks.get(spanSinkKey(span.spanContext().traceId, parentSpanId));
+		if (!sink) return;
+		this.trackSpan(span, sink);
+	}
+	/**
+	* On end, extract any AI metadata from the span's attributes and push it to
+	* its sink, then clean up the span's tracking entry.
+	*/
+	onEnd(span) {
+		const { traceId, spanId } = span.spanContext();
+		try {
+			const sink = this.#spanSinks.get(spanSinkKey(traceId, spanId));
+			if (!sink) return;
+			const aiMetadata = require_aiExtractor.extractAIMetadataFromAttributes(span.attributes);
+			if (Object.keys(aiMetadata).length === 0) return;
+			sink(aiMetadata);
+		} finally {
+			this.cleanupSpan(span);
+		}
+	}
+	async forceFlush() {}
+	async shutdown() {}
+};
+/**
+* The process-wide metadata span processor instance.
+*/
+const metadataSpanProcessor = new InngestMetadataSpanProcessor();
+
+//#endregion
+exports.metadataSpanProcessor = metadataSpanProcessor;
+//# sourceMappingURL=metadataProcessor.cjs.map

package/components/execution/otel/metadataProcessor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataProcessor.cjs","names":["debugPrefix","trace","isRecord","#spanSinks","#attached","#spanCleanup","extractAIMetadataFromAttributes"],"sources":["../../../../src/components/execution/otel/metadataProcessor.ts"],"sourcesContent":["import { type Context, type Span, trace } from \"@opentelemetry/api\";\nimport type {\n  ReadableSpan,\n  SpanProcessor,\n} from \"@opentelemetry/sdk-trace-base\";\nimport Debug from \"debug\";\nimport { isRecord } from \"../../../helpers/types.ts\";\nimport {\n  type AIMetadata,\n  extractAIMetadataFromAttributes,\n} from \"./aiExtractor.ts\";\nimport { debugPrefix } from \"./consts.ts\";\n\nconst processorDevDebug = Debug(`${debugPrefix}:InngestMetadataSpanProcessor`);\n\n/**\n * Receives {@link AIMetadata} extracted from a span the moment it ends.\n * Supplied by the engine; the engine owns all aggregation and\n * step-attribution of the pushed values.\n */\nexport type AIMetadataSink = (metadata: AIMetadata) => void;\n\n/**\n * Resolve the currently-registered global OTel tracer provider, unwrapping\n * the `ProxyTracerProvider` wrapper that `trace.getTracerProvider()` returns.\n * Returns `undefined` when no provider is registered.\n */\nconst getGlobalProvider = (): object | undefined => {\n  const globalProvider = trace.getTracerProvider();\n  if (!globalProvider) {\n    return undefined;\n  }\n\n  const existingProvider =\n    \"getDelegate\" in globalProvider &&\n    typeof globalProvider.getDelegate === \"function\"\n      ? globalProvider.getDelegate()\n      : globalProvider;\n\n  return existingProvider ?? undefined;\n};\n\n/**\n * Attempts to add the given span processor to the given OTel provider.\n * Returns `true` if the processor was attached, `false` if the provider could\n * not be extended.\n *\n * It handles both OTel SDK v1 (`addSpanProcessor()`) and v2 (internal\n * `_spanProcessors` array).\n *\n * This intentionally duplicates the attach logic inside `extendProvider`\n * (`util.ts`) to avoid imports with instrumentation side effects.\n */\nconst attachToProvider = (\n  provider: object,\n  processor: SpanProcessor,\n): boolean => {\n  // OTel SDK v1 exposes addSpanProcessor() on BasicTracerProvider.\n  if (\n    \"addSpanProcessor\" in provider &&\n    typeof (provider as { addSpanProcessor?: unknown }).addSpanProcessor ===\n      \"function\"\n  ) {\n    (\n      provider as unknown as {\n        addSpanProcessor: (p: SpanProcessor) => void;\n      }\n    ).addSpanProcessor(processor);\n    return true;\n  }\n\n  // OTel SDK v2 removed addSpanProcessor() — span processors are constructor-only.\n  // No public API exists to add processors post-construction (OTel issue #5299),\n  // so push into the internal _spanProcessors array.\n  // These fields are TypeScript `private` (not #private), so accessible at runtime.\n  const spanProcessors = getInternalSpanProcessors(provider);\n  if (spanProcessors) {\n    spanProcessors.push(processor);\n    return true;\n  }\n\n  return false;\n};\n\n/**\n * Extract the internal span processors array from a BasicTracerProvider.\n * Returns the mutable array if accessible, undefined otherwise.\n *\n * BasicTracerProvider._activeSpanProcessor is a MultiSpanProcessor,\n * which holds a _spanProcessors: SpanProcessor[] array.\n * Both are TypeScript `private` (not ES #private), so accessible at runtime.\n *\n * Wrapped in try/catch because this accesses internal OTel fields that may\n * change — must never crash the host app.\n */\nfunction getInternalSpanProcessors(provider: unknown): unknown[] | undefined {\n  if (!isRecord(provider)) {\n    return undefined;\n  }\n\n  try {\n    const active = provider._activeSpanProcessor;\n    if (!isRecord(active)) return undefined;\n\n    const arr = active._spanProcessors;\n    return Array.isArray(arr) ? arr : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Builds the `#spanSinks` key for a span. Span IDs are only guaranteed unique\n * within a single trace, so spans are keyed by trace ID + span ID to avoid\n * cross-trace collisions.\n */\nconst spanSinkKey = (traceId: string, spanId: string): string =>\n  `${traceId}:${spanId}`;\n\n/**\n * A read-only OTel span processor that is independent of the Extended Traces\n * processor (`InngestSpanProcessor`).\n *\n * It tracks which spans belong to an Inngest step (seeded by\n * {@link declareStartingSpan} and passed from parent to child in `onStart`).\n *\n * When a tracked span ends, it extracts {@link AIMetadata} from the span's\n * attributes and pushes it to the span's {@link AIMetadataSink}.\n */\nexport class InngestMetadataSpanProcessor implements SpanProcessor {\n  /**\n   * A map of tracked spans to their sink.\n   *\n   * We use traceId:spanID as the key, which uniquely identifies each span. See\n   * {@link spanSinkKey}\n   *\n   * The engine seeds the map during {@link declareStartingSpan} with the root\n   * span and its sink.\n   *\n   * During onStart, the processor looks up the span's parent's sink and then\n   * records the span as also using that sink. If the parent is not found, then\n   * the span is not descended from a root step span, and therefore does not\n   * need to have a sink.\n   *\n   * All spans with the same root span that started the step will share the\n   * same sink.\n   */\n  #spanSinks = new Map<string, AIMetadataSink>();\n\n  /**\n   * A registry used to clean up items from `#spanSinks` when spans fall out of\n   * reference without ending. Avoids leaking entries (and the engine sink\n   * closures they reference) for spans that are never ended and are GC'd.\n   */\n  #spanCleanup = new FinalizationRegistry<string>((key) => {\n    if (key) {\n      this.#spanSinks.delete(key);\n    }\n  });\n\n  /**\n   * Latches once this processor has been attached to a global OTel provider, so\n   * {@link attach} can never push it into a provider's processor list twice\n   * (which would double-process every span and double-count tokens).\n   */\n  #attached = false;\n\n  /**\n   * Idempotently attach this processor to the global OTel provider that already\n   * exists, so it begins receiving span lifecycle events.\n   */\n  attach(): void {\n    if (this.#attached) {\n      return;\n    }\n\n    const provider = getGlobalProvider();\n    if (!provider) {\n      return;\n    }\n\n    if (attachToProvider(provider, this)) {\n      this.#attached = true;\n      processorDevDebug(\"attached to global OTel provider\");\n    }\n  }\n\n  /**\n   * Declare the step's root span. Seeds tracking so that the root and all of\n   * its descendants share the same AIMetadata sink.\n   */\n  public declareStartingSpan({\n    span,\n    traceparent,\n    onAIMetadata,\n  }: {\n    span: Span;\n    traceparent: string | undefined;\n    onAIMetadata: AIMetadataSink;\n  }): void {\n    // If this processor is not attached to a  provider, we don't need to\n    // declare starting spans.\n    if (!this.#attached) {\n      return;\n    }\n\n    // If we don't have a traceparent, then this isn't a step the Executor is\n    // tracking, so we don't track it either.\n    if (!traceparent) {\n      return processorDevDebug(\n        \"no traceparent found for span\",\n        span.spanContext().spanId,\n        \"so skipping it\",\n      );\n    }\n\n    this.trackSpan(span, onAIMetadata);\n  }\n\n  /**\n   * Mark a span as tracked, recording its step's sink and registering it for\n   * cleanup.\n   *\n   * Read-only: unlike the Extended Traces processor, no attributes\n   * are stamped on the span.\n   */\n  private trackSpan(span: Span, sink: AIMetadataSink): void {\n    const { traceId, spanId } = span.spanContext();\n    const key = spanSinkKey(traceId, spanId);\n\n    this.#spanCleanup.register(span, key, span);\n    this.#spanSinks.set(key, sink);\n  }\n\n  /**\n   * Clean up references to a span that has ended (or been GC'd).\n   */\n  private cleanupSpan(span: ReadableSpan): void {\n    const { traceId, spanId } = span.spanContext();\n    this.#spanCleanup.unregister(span);\n    this.#spanSinks.delete(spanSinkKey(traceId, spanId));\n  }\n\n  /**\n   * Track children of spans we already care about, so the whole subtree under a\n   * declared root is captured.\n   */\n  onStart(span: Span, parentContext: Context): void {\n    const parentSpanId = trace.getSpanContext(parentContext)?.spanId;\n\n    if (!parentSpanId) {\n      return;\n    }\n\n    // A child span always shares its parent's trace ID, so the parent's key\n    // can be built from the child's own span context.\n    const sink = this.#spanSinks.get(\n      spanSinkKey(span.spanContext().traceId, parentSpanId),\n    );\n    if (!sink) {\n      return;\n    }\n\n    this.trackSpan(span, sink);\n  }\n\n  /**\n   * On end, extract any AI metadata from the span's attributes and push it to\n   * its sink, then clean up the span's tracking entry.\n   */\n  onEnd(span: ReadableSpan): void {\n    const { traceId, spanId } = span.spanContext();\n\n    try {\n      const sink = this.#spanSinks.get(spanSinkKey(traceId, spanId));\n      if (!sink) {\n        return;\n      }\n\n      const aiMetadata = extractAIMetadataFromAttributes(span.attributes);\n      if (Object.keys(aiMetadata).length === 0) {\n        return;\n      }\n\n      sink(aiMetadata);\n    } finally {\n      this.cleanupSpan(span);\n    }\n  }\n\n  // Nothing to flush or shut down: this processor is read-only and has no\n  // exporter.\n  async forceFlush(): Promise<void> {}\n\n  async shutdown(): Promise<void> {}\n}\n\n/**\n * The process-wide metadata span processor instance.\n */\nexport const metadataSpanProcessor = new InngestMetadataSpanProcessor();\n"],"mappings":";;;;;;;;;AAaA,MAAM,uCAA0B,GAAGA,2BAAY,+BAA+B;;;;;;AAc9E,MAAM,0BAA8C;CAClD,MAAM,iBAAiBC,0BAAM,mBAAmB;AAChD,KAAI,CAAC,eACH;AASF,SALE,iBAAiB,kBACjB,OAAO,eAAe,gBAAgB,aAClC,eAAe,aAAa,GAC5B,mBAEqB;;;;;;;;;;;;;AAc7B,MAAM,oBACJ,UACA,cACY;AAEZ,KACE,sBAAsB,YACtB,OAAQ,SAA4C,qBAClD,YACF;AACA,EACE,SAGA,iBAAiB,UAAU;AAC7B,SAAO;;CAOT,MAAM,iBAAiB,0BAA0B,SAAS;AAC1D,KAAI,gBAAgB;AAClB,iBAAe,KAAK,UAAU;AAC9B,SAAO;;AAGT,QAAO;;;;;;;;;;;;;AAcT,SAAS,0BAA0B,UAA0C;AAC3E,KAAI,CAACC,uBAAS,SAAS,CACrB;AAGF,KAAI;EACF,MAAM,SAAS,SAAS;AACxB,MAAI,CAACA,uBAAS,OAAO,CAAE,QAAO;EAE9B,MAAM,MAAM,OAAO;AACnB,SAAO,MAAM,QAAQ,IAAI,GAAG,MAAM;SAC5B;AACN;;;;;;;;AASJ,MAAM,eAAe,SAAiB,WACpC,GAAG,QAAQ,GAAG;;;;;;;;;;;AAYhB,IAAa,+BAAb,MAAmE;;;;;;;;;;;;;;;;;;CAkBjE,6BAAa,IAAI,KAA6B;;;;;;CAO9C,eAAe,IAAI,sBAA8B,QAAQ;AACvD,MAAI,IACF,OAAKC,UAAW,OAAO,IAAI;GAE7B;;;;;;CAOF,YAAY;;;;;CAMZ,SAAe;AACb,MAAI,MAAKC,SACP;EAGF,MAAM,WAAW,mBAAmB;AACpC,MAAI,CAAC,SACH;AAGF,MAAI,iBAAiB,UAAU,KAAK,EAAE;AACpC,SAAKA,WAAY;AACjB,qBAAkB,mCAAmC;;;;;;;CAQzD,AAAO,oBAAoB,EACzB,MACA,aACA,gBAKO;AAGP,MAAI,CAAC,MAAKA,SACR;AAKF,MAAI,CAAC,YACH,QAAO,kBACL,iCACA,KAAK,aAAa,CAAC,QACnB,iBACD;AAGH,OAAK,UAAU,MAAM,aAAa;;;;;;;;;CAUpC,AAAQ,UAAU,MAAY,MAA4B;EACxD,MAAM,EAAE,SAAS,WAAW,KAAK,aAAa;EAC9C,MAAM,MAAM,YAAY,SAAS,OAAO;AAExC,QAAKC,YAAa,SAAS,MAAM,KAAK,KAAK;AAC3C,QAAKF,UAAW,IAAI,KAAK,KAAK;;;;;CAMhC,AAAQ,YAAY,MAA0B;EAC5C,MAAM,EAAE,SAAS,WAAW,KAAK,aAAa;AAC9C,QAAKE,YAAa,WAAW,KAAK;AAClC,QAAKF,UAAW,OAAO,YAAY,SAAS,OAAO,CAAC;;;;;;CAOtD,QAAQ,MAAY,eAA8B;EAChD,MAAM,eAAeF,0BAAM,eAAe,cAAc,EAAE;AAE1D,MAAI,CAAC,aACH;EAKF,MAAM,OAAO,MAAKE,UAAW,IAC3B,YAAY,KAAK,aAAa,CAAC,SAAS,aAAa,CACtD;AACD,MAAI,CAAC,KACH;AAGF,OAAK,UAAU,MAAM,KAAK;;;;;;CAO5B,MAAM,MAA0B;EAC9B,MAAM,EAAE,SAAS,WAAW,KAAK,aAAa;AAE9C,MAAI;GACF,MAAM,OAAO,MAAKA,UAAW,IAAI,YAAY,SAAS,OAAO,CAAC;AAC9D,OAAI,CAAC,KACH;GAGF,MAAM,aAAaG,oDAAgC,KAAK,WAAW;AACnE,OAAI,OAAO,KAAK,WAAW,CAAC,WAAW,EACrC;AAGF,QAAK,WAAW;YACR;AACR,QAAK,YAAY,KAAK;;;CAM1B,MAAM,aAA4B;CAElC,MAAM,WAA0B;;;;;AAMlC,MAAa,wBAAwB,IAAI,8BAA8B"}