@mark1russell7/kind 0.9.0 → 0.10.1

package/README.md

@@ -148,7 +148,9 @@ A new member of the union `Template` breaks a reader that switches on it. That i
 
 ## The image
 
-The lab image (`image/`) holds the service of a cell on `@mark1russell7/service`, its clients, the agent and the watcher, on Node 24.21.0. Its base is pinned by digest, and `npm-lock.json` pins the packages from npm. `stageLabImage()` stages its context, and `labImage()` tags the image by its content.
+The lab image (`image/`) holds the service of a cell on `@mark1russell7/service`, its clients, the agent and the watcher, on Node 24.21.0. Its base is pinned by digest, and `npm-lock.json` pins the packages from npm. `stageLabImage()` stages its context, and `labImage()` gives the tag of the image.
+
+- **The resolver.** From 0.10.1, the lab image is a `build` source of the harness (`labSource()`). The resolver of the harness plans it and builds it, as it does each other image (`planOf`, `imageOf`). Thus its tag comes from its content, and each `FROM` has a digest. Each manifest of packages has a lockfile, and a failed build tries again after each wait. The build goes through the CLI of Docker, not through Testcontainers.
 
 - **In the workspace** of this repository, the stage builds `@mark1russell7/quantity`, `@mark1russell7/algebra` and `@mark1russell7/service`, and packs each one as npm gets it.
 - **From npm**, the stage packs the installed versions of the same packages. The package holds the files of the image, and `src/compose.ts` and `src/backends.ts`, for that.
@@ -202,6 +204,7 @@ The plan's `event:clock-jump` has no trigger. A step of CLOCK_REALTIME in the VM
 `predict.ts` gives each band from the declaration, the pod settings and the calibration of the propagation:
 
 - **A deletion.** The listener of a leaving pod stays open for its preStop sleep and the hold of `fail readiness`. A connection fails when the rules of its node select the pod after that. `rules.ts` gives O04 with the hold as data, and `lint()` decides it.
+- **The way that a plan stops a pod.** `stopOf(cell)` reads it from the trigger: a deletion, a liveness restart, a crash, or null when the plan stops no pod. `lintCell()` gives each cell only the drain rules that guard its way (`lintStop()` of the service). A plan that stops no pod gets each drain rule. A crash gets no drain rule, and its finding of `stop` depends.
 - **A pause of kube-proxy** keeps the rules of one node for its hold. The window on that node ends one propagation after the pause. A SYN_SENT entry of an earlier run lives up to 122 s, thus the window also opens up to 122 s before the intake. `predictionText` writes each end of a window with its band, for example `the intake + [-122, 4.605] s`.
 - **A reset from a leaving pod** leaves the conntrack entry of its flow in CLOSE for 10 s, with the NAT to that pod. From 0.1.6, a window can give that life (`afterReset`). Then a request outside the window can fail with the outcome of the rule (`reusesReset`). The condition is a reset of the same client on the same port, up to that life before the request. The catalog gives it to a deletion without a hold, in the modes with the NAT in conntrack.
 - **A fault of a shared dependency** trips the readiness latch of each replica (`failSpan`). Then the kubelet needs its threshold of probes, and the rules need one propagation.

package/build/index.d.ts

@@ -1,6 +1,7 @@
 import { $ as updatesOf, $t as Declaration, A as TriggerV1, An as scenario, At as rulesOf, B as RunCheck, Bt as ztunnelPodsOf, C as KindCellResult, Cn as NodeImage, Ct as outcomesOf, D as PredictionV1, Dn as kindConfig, Dt as requestsOf, E as LoadSample, En as goDuration, Et as recordsOf, F as KIND_NOISE, Ft as slicesOf, G as judgeKind, Gt as PORT, H as checkRun, Ht as CLIENT, I as KindDecision, It as socketsOf, J as propagationOf, Jt as bandOf, K as observationAfter, Kt as REDIS, L as KindVerdict, Lt as stoppingOf, M as upgrade, Mt as signalsOf, N as upgradeCell, Nt as sliceDropOf, O as RunCheckV1, On as kubeProxyPatch, Ot as restartOf, P as Deleted, Pt as sliceEmptyOf, Q as unitOf, Qt as Band, R as LAST_SLACK, Rt as transitionOf, S as KindCellRecordV1, Sn as NODE_IMAGES, St as kernelCounts, T as KindVerdictV1, Tn as cidrRange, Tt as podsOf, U as deletionsOf, Ut as HEALTH_PORT, V as RunFacts, Vt as ztunnelReplaced, W as factsOf, Wt as LOG_LABEL, X as referenceOf, Xt as secondsOf, Y as propagationSource, Yt as seconds, Z as reusesReset, Zt as showBand, _ as ClusterManifest, _n as Workload, _t as dropOf, a as STAGES, an as MeshMode, at as RecordLine, b as FORMAT_V1, bn as KindScenario, bt as intakeOf, c as readRecord, cn as RedisDeclaration, ct as SliceLine, d as calibrationOf, dn as ResetReuse, dt as TunnelLine, en as KindCell, et as Endpoint, f as cellsTable, fn as Stack, ft as ZtunnelPodLine, g as BandV1, gn as WindowPrediction, gt as deletionOf, h as timeSpread, hn as TriggerKind, ht as byNode, i as quantileOf, in as MeshFlavor, it as PropagationSource, j as judge, jn as scenarioProblems, jt as signalOf, k as RunFactsV1, kn as nodeNames, kt as restartsAt, l as Judged, ln as Reference, lt as SocketLine, m as predictionText, mn as Trigger, mt as byClients, n as medianInterval, nn as KubeletProbe, nt as Line, o as kindCellRecordSchema, on as PodSettings, ot as Request, p as medianText, pn as Template, pt as backendsAt, q as observationEnd, qt as SERVER, r as middle, rn as Mesh, rt as PodLine, s as kindCellRecordV1Schema, sn as Prediction, st as RulesLine, t as RELATIVE, tn as KindRun, tt as HBONE_PORT, u as TimeSpread, un as Replica, ut as TCP_STATE, v as EnvironmentManifest, vn as KUBE_PROXY_MODES, vt as emptyOf, w as KindCellV1, wn as cidrOverlap, wt as podsAt, x as KindCellRecord, xn as KubeProxyMode, xt as isTunnelState, y as FORMAT, yn as KindConfig, yt as failuresOf, z as Propagated, zt as tunnelsOf } from "./judge-BD4UVQfy.js";
 import { Quantity } from "@mark1russell7/quantity";
-import { CheckFn, Finding, HealthServer, Poll, Rule, Scenario, ServiceBuilder, ServiceDescription, Stage, Timing, TransportImpl, Verdict } from "@mark1russell7/service";
+import { CheckFn, Finding, HealthServer, Poll, Rule, Scenario, ServiceBuilder, ServiceDescription, Stage, StopWay, Timing, TransportImpl, Verdict } from "@mark1russell7/service";
+import { BuildImage } from "@mark1russell7/harness";
 import { RedisClient } from "@mark1russell7/service/redis";
 //#region src/backends.d.ts
 /** A service rule names the Service whose backends the agent reads: its namespace, its name, and its ClusterIP and port for IPVS. */
@@ -266,9 +267,16 @@ export declare const deletes: (cell: KindCell) => boolean;
  */
 export declare const stageLabImage: () => string;
 /**
- * This function builds the lab image one time for each process, and gives its tag. Docker keeps its
- * layers between builds. A build that fails leaves the cache. Thus a later call builds again after a
- * fault of Docker or of the network.
+ * This function gives the source of the lab image from a staged context, as a `build` source of
+ * the harness. The resolver of the harness plans it and builds it, as it does each other image.
+ * Thus each `FROM` has a digest, and each manifest of packages has a lockfile.
+ */
+export declare const labSource: (context: string) => BuildImage;
+/**
+ * This function gives the tag of the lab image, one time for each process. It stages the context,
+ * and the resolver of the harness builds it with a tag from its content (`imageOf`). The stage
+ * builds and packs packages, thus a tag that passed stays. A stage or a build that fails leaves
+ * the cache. Thus a later call stages and builds again after a fault of Docker or of the network.
  */
 export declare const labImage: () => Promise<string>;
 //#endregion
@@ -649,7 +657,7 @@ export declare const O09: Rule;
 export declare const O10: Rule;
 /** O16: the cooperative window is shorter than the drain, which is shorter than the grace less the preStop sleep. */
 export declare const O16: Rule;
-/** These are the rules of the drain that each kind cell gets. */
+/** These are the rules of the drain. A kind cell gets the rules that guard the way that its plan stops a pod. */
 export declare const DRAIN_RULES: readonly Rule[];
 /**
  * This function gives the scenario of a cell for `lint()`: the preStop sleep, the grace, the probe
@@ -658,7 +666,19 @@ export declare const DRAIN_RULES: readonly Rule[];
 export declare const scenarioOf: (cell: KindCell, propagation: Propagation) => Scenario;
 /** A verdict set is the verdict of each drain rule for one declaration, by the identifier of the rule. */
 type Verdicts = Readonly<Record<string, Verdict>>;
-/** This function applies the drain rules to the description of a cell, and gives each finding. */
+/**
+ * This function gives the way that the fault plan of a cell stops a pod, or null when the plan stops no pod.
+ * - A deletion, a rolling update, a node drain, a scale-in and a rollout delete a pod with its grace.
+ * - In T07 a pause of kube-proxy comes before a deletion. In T18 the pause is on Redis.
+ * - The crash of the lab is SIGKILL from the node. Like a crash, it has no preStop hook and no drain.
+ * - The other faults are on a link, on Redis or on the process. The kubelet can restart a pod after them.
+ */
+export declare const stopOf: (cell: KindCell) => StopWay | null;
+/**
+ * This function applies the drain rules to the description of a cell, and gives each finding. A cell
+ * whose plan stops a pod gets the rules of that way (`lintStop()`). A plan that stops no pod gets each
+ * drain rule, because a restart by the kubelet or a later deletion can follow its fault.
+ */
 export declare const lintCell: (description: ServiceDescription, cell: KindCell, propagation: Propagation) => Finding[];
 /** This function gives the verdict of each drain rule, by its identifier. */
 export declare const verdictsOf: (findings: readonly Finding[]) => Verdicts;

package/build/index.js

@@ -1,13 +1,13 @@
 import { $ as signalOf, A as medianInterval, B as emptyOf, C as propagationOf, D as unitOf, E as reusesReset, F as backendsAt, G as outcomesOf, H as intakeOf, I as byClients, J as recordsOf, K as podsAt, L as byNode, M as quantileOf, N as HBONE_PORT, O as updatesOf, P as TCP_STATE, Q as rulesOf, R as deletionOf, S as observationEnd, T as referenceOf, U as isTunnelState, V as failuresOf, W as kernelCounts, X as restartOf, Y as requestsOf, Z as restartsAt, _ as checkRun, _t as seconds, a as calibrationOf, at as stoppingOf, b as judgeKind, c as predictionText, ct as ztunnelPodsOf, d as FORMAT_V1, dt as HEALTH_PORT, et as signalsOf, f as judge, ft as LOG_LABEL, g as LAST_SLACK, gt as bandOf, h as KIND_NOISE, ht as SERVER, i as readRecord, it as socketsOf, j as middle, k as RELATIVE, l as timeSpread, lt as ztunnelReplaced, m as upgradeCell, mt as REDIS, n as kindCellRecordSchema, nt as sliceEmptyOf, o as cellsTable, ot as transitionOf, p as upgrade, pt as PORT, q as podsOf, r as kindCellRecordV1Schema, rt as slicesOf, s as medianText, st as tunnelsOf, t as STAGES, tt as sliceDropOf, u as FORMAT, ut as CLIENT, v as deletionsOf, vt as secondsOf, w as propagationSource, x as observationAfter, y as factsOf, yt as showBand, z as dropOf } from "./judge-BbLWVTYj.js";
 import { valueIn } from "@mark1russell7/quantity";
 import { execFile, execFileSync } from "node:child_process";
-import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { gunzipSync } from "node:zlib";
-import { failSpan, lint, service } from "@mark1russell7/service";
+import { failSpan, lint, lintStop, service } from "@mark1russell7/service";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { harnessImage, imageOf } from "@mark1russell7/harness";
@@ -1269,6 +1269,8 @@ const WORKSPACE_PACKAGES = [
 	"algebra",
 	"service"
 ];
+/** This folder of a staged context holds the tarball of each package of the workspace. */
+const PACKED = "workspace";
 /** These are the files of the image, by their name in the context and their source in the package. */
 const FILES = [
 	["Dockerfile", "image/Dockerfile"],
@@ -1288,17 +1290,6 @@ const FILES = [
 	["client-lines.ts", "src/client-lines.ts"]
 ];
 const shell = process.platform === "win32";
-/** This function gives each file of a staged context, with its path in the context, in a stable sequence. */
-const filesOf = (root, at = "") => readdirSync(join(root, at), { withFileTypes: true }).flatMap((entry) => entry.isDirectory() ? filesOf(root, join(at, entry.name)) : [join(at, entry.name)]).sort();
-/** This function gives the tag of a staged context from its content: the name, then 12 digits of a sha256. */
-const contentTag = (name, root) => {
-	const hash = createHash("sha256");
-	for (const file of filesOf(root)) {
-		hash.update(file.replaceAll("\\", "/"));
-		hash.update(readFileSync(join(root, file)));
-	}
-	return `${name}:${hash.digest("hex").slice(0, 12)}`;
-};
 /** This function tells if the package is in the workspace of its repository. From npm, it is not. */
 const inWorkspace = () => existsSync(join(REPO, "pnpm-workspace.yaml")) && WORKSPACE_PACKAGES.every((name) => existsSync(join(REPO, "packages", name, "package.json")));
 /**
@@ -1328,7 +1319,7 @@ const installedFolders = () => {
 */
 const stageLabImage = () => {
 	const context = mkdtempSync(join(tmpdir(), "systems-kind-lab-"));
-	const packed = join(context, "workspace");
+	const packed = join(context, PACKED);
 	mkdirSync(packed);
 	if (inWorkspace()) {
 		const filters = WORKSPACE_PACKAGES.flatMap((name) => ["--filter", `@mark1russell7/${name}`]);
@@ -1359,21 +1350,30 @@ const stageLabImage = () => {
 	for (const [at, from] of FILES) copyFileSync(join(PACKAGE, from), join(context, at));
 	return context;
 };
+/**
+* This function gives the source of the lab image from a staged context, as a `build` source of
+* the harness. The resolver of the harness plans it and builds it, as it does each other image.
+* Thus each `FROM` has a digest, and each manifest of packages has a lockfile.
+*/
+const labSource = (context) => ({
+	kind: "build",
+	name: "systems-kind-lab",
+	context,
+	files: [...FILES.map(([at]) => at), PACKED]
+});
 let built = null;
 /**
-* This function builds the lab image one time for each process, and gives its tag. Docker keeps its
-* layers between builds. A build that fails leaves the cache. Thus a later call builds again after a
-* fault of Docker or of the network.
+* This function gives the tag of the lab image, one time for each process. It stages the context,
+* and the resolver of the harness builds it with a tag from its content (`imageOf`). The stage
+* builds and packs packages, thus a tag that passed stays. A stage or a build that fails leaves
+* the cache. Thus a later call stages and builds again after a fault of Docker or of the network.
 */
 const labImage = () => {
 	if (built !== null) return built;
 	const building = (async () => {
 		const context = stageLabImage();
 		try {
-			const tag = contentTag("systems-kind-lab", context);
-			const { GenericContainer } = await import("testcontainers");
-			await GenericContainer.fromDockerfile(context).build(tag, { deleteOnExit: false });
-			return tag;
+			return await imageOf(labSource(context));
 		} finally {
 			rmSync(context, {
 				recursive: true,
@@ -2657,7 +2657,7 @@ const O16 = {
 		}] }
 	}]
 };
-/** These are the rules of the drain that each kind cell gets. */
+/** These are the rules of the drain. A kind cell gets the rules that guard the way that its plan stops a pod. */
 const DRAIN_RULES = [
 	O04,
 	O09,
@@ -2685,8 +2685,44 @@ const scenarioOf = (cell, propagation) => ({
 		liveness: s(seconds$1(cell.pod.liveness.period) * cell.pod.liveness.threshold)
 	}
 });
-/** This function applies the drain rules to the description of a cell, and gives each finding. */
-const lintCell = (description, cell, propagation) => lint(description, scenarioOf(cell, propagation), DRAIN_RULES);
+/**
+* This function gives the way that the fault plan of a cell stops a pod, or null when the plan stops no pod.
+* - A deletion, a rolling update, a node drain, a scale-in and a rollout delete a pod with its grace.
+* - In T07 a pause of kube-proxy comes before a deletion. In T18 the pause is on Redis.
+* - The crash of the lab is SIGKILL from the node. Like a crash, it has no preStop hook and no drain.
+* - The other faults are on a link, on Redis or on the process. The kubelet can restart a pod after them.
+*/
+const stopOf = (cell) => {
+	switch (cell.trigger.kind) {
+		case "pod-deletion":
+		case "rolling-update":
+		case "node-drain":
+		case "scale-in":
+		case "rollout": return "deletion";
+		case "freeze-process": return cell.template === "T07" ? "deletion" : null;
+		case "crash": return "crash";
+		case "liveness-restart": return "liveness-restart";
+		case "rst":
+		case "blackhole":
+		case "peer-gone-without-close":
+		case "app-stall":
+		case "cpu-throttle":
+		case "authorization-policy":
+		case "idle":
+		case "ztunnel-restart":
+		case "certificate-expiry": return null;
+	}
+};
+/**
+* This function applies the drain rules to the description of a cell, and gives each finding. A cell
+* whose plan stops a pod gets the rules of that way (`lintStop()`). A plan that stops no pod gets each
+* drain rule, because a restart by the kubelet or a later deletion can follow its fault.
+*/
+const lintCell = (description, cell, propagation) => {
+	const way = stopOf(cell);
+	const scenario = scenarioOf(cell, propagation);
+	return way === null ? lint(description, scenario, DRAIN_RULES) : lintStop(description, scenario, DRAIN_RULES, way);
+};
 /** This function gives the verdict of each drain rule, by its identifier. */
 const verdictsOf = (findings) => Object.fromEntries(findings.map((finding) => [finding.rule, finding.verdict]));
 /** This function gives the description of the service of a cell, as the app of the image composes it. Nothing connects. */
@@ -3687,6 +3723,6 @@ const shardOf = (cells, index, count) => {
 	return out;
 };
 //#endregion
-export { ACCESS_LOG_FORMAT, CHANNEL_USE, CLIENT, CLIENT_ACCOUNT, CLOSE_LEAD, CONTROLLER, DOCUMENTED, DRAIN_RULES, EDS_EVERY, FLAG_CHECK, FORMAT, FORMAT_V1, HBONE_PORT, HEALTH_PORT, ISTIOCTL, ISTIO_IMAGES, ISTIO_VERSION, KEPT_KERNEL, KIND, KIND_NOISE, KUBECTL, KUBE_PROXY_MODES, LAST_SLACK, LDS_EVERY, LDS_FILTER, LOG_LABEL, MESH_IMAGES, MESH_WORKLOADS, MIDDLEBOX, NETNS_DEFAULTS, NODE_IMAGES, O04, O09, O10, O16, POLICY, PORT, QUIET_LEAD, REDIS, REDIS_IMAGE, RELATIVE, ROUTE, RULES_EVERY, SERVER, STAGES, SYSCTL, TCP_STATE, WATCHDOG, ZTUNNEL_PODS, backendsAt, backendsOf, bandOf, byClients, byNode, cacheFolder, calibrationOf, capOf, cellsTable, certificateArgs, checkRun, cidrOverlap, cidrRange, clientObjects, clusterFilter, compose, createCluster, deletes, deletionOf, deletionWindow, deletionsOf, describeCell, dropOf, emptyOf, ensureTool, estimatedTime, factsOf, failuresOf, followsZtunnel, goDuration, hostsOf, installMesh, intakeAfter, intakeOf, isTunnelState, istioOperator, judge, judgeKind, keptKernel, kernelCounts, kindCellRecordSchema, kindCellRecordV1Schema, kindConfig, kubeProxyPatch, kubeletBand, labImage, latchBand, leafCertificates, lintCell, listenerCountsOf, localPin, medianInterval, medianText, meshKey, middle, middleboxCommands, namespaceObject, namespaceOf, nodeNames, observationAfter, observationEnd, openKindLab, outboundCluster, outcomesOf, pausedWindow, planOf, platformKey, podsAt, podsOf, policyObject, pollsListeners, predictionText, probeOf, propagationOf, propagationSource, quantileOf, readRecord, recordsOf, redisObjects, referenceOf, removalBand, requestsOf, restartBand, restartOf, restartsAt, reusesReset, rulesOf, runKindCells, scenario, scenarioOf, scenarioProblems, seconds, secondsOf, serverCluster, serverObjects, setZtunnelEnv, sha256, shardOf, showBand, signalOf, signalsOf, sliceDropOf, sliceEmptyOf, slicesOf, socketsOf, stackOf, stageLabImage, stallRemovalBand, stoppingOf, sysctlCommand, tarEntry, timeSpread, toolPath, transitionOf, tunnelsOf, unitOf, updatesOf, upgrade, upgradeCell, verdictsOf, writeResult, ztunnelCertificates, ztunnelEnvArgs, ztunnelPodsOf, ztunnelReplaced };
+export { ACCESS_LOG_FORMAT, CHANNEL_USE, CLIENT, CLIENT_ACCOUNT, CLOSE_LEAD, CONTROLLER, DOCUMENTED, DRAIN_RULES, EDS_EVERY, FLAG_CHECK, FORMAT, FORMAT_V1, HBONE_PORT, HEALTH_PORT, ISTIOCTL, ISTIO_IMAGES, ISTIO_VERSION, KEPT_KERNEL, KIND, KIND_NOISE, KUBECTL, KUBE_PROXY_MODES, LAST_SLACK, LDS_EVERY, LDS_FILTER, LOG_LABEL, MESH_IMAGES, MESH_WORKLOADS, MIDDLEBOX, NETNS_DEFAULTS, NODE_IMAGES, O04, O09, O10, O16, POLICY, PORT, QUIET_LEAD, REDIS, REDIS_IMAGE, RELATIVE, ROUTE, RULES_EVERY, SERVER, STAGES, SYSCTL, TCP_STATE, WATCHDOG, ZTUNNEL_PODS, backendsAt, backendsOf, bandOf, byClients, byNode, cacheFolder, calibrationOf, capOf, cellsTable, certificateArgs, checkRun, cidrOverlap, cidrRange, clientObjects, clusterFilter, compose, createCluster, deletes, deletionOf, deletionWindow, deletionsOf, describeCell, dropOf, emptyOf, ensureTool, estimatedTime, factsOf, failuresOf, followsZtunnel, goDuration, hostsOf, installMesh, intakeAfter, intakeOf, isTunnelState, istioOperator, judge, judgeKind, keptKernel, kernelCounts, kindCellRecordSchema, kindCellRecordV1Schema, kindConfig, kubeProxyPatch, kubeletBand, labImage, labSource, latchBand, leafCertificates, lintCell, listenerCountsOf, localPin, medianInterval, medianText, meshKey, middle, middleboxCommands, namespaceObject, namespaceOf, nodeNames, observationAfter, observationEnd, openKindLab, outboundCluster, outcomesOf, pausedWindow, planOf, platformKey, podsAt, podsOf, policyObject, pollsListeners, predictionText, probeOf, propagationOf, propagationSource, quantileOf, readRecord, recordsOf, redisObjects, referenceOf, removalBand, requestsOf, restartBand, restartOf, restartsAt, reusesReset, rulesOf, runKindCells, scenario, scenarioOf, scenarioProblems, seconds, secondsOf, serverCluster, serverObjects, setZtunnelEnv, sha256, shardOf, showBand, signalOf, signalsOf, sliceDropOf, sliceEmptyOf, slicesOf, socketsOf, stackOf, stageLabImage, stallRemovalBand, stopOf, stoppingOf, sysctlCommand, tarEntry, timeSpread, toolPath, transitionOf, tunnelsOf, unitOf, updatesOf, upgrade, upgradeCell, verdictsOf, writeResult, ztunnelCertificates, ztunnelEnvArgs, ztunnelPodsOf, ztunnelReplaced };
 
 //# sourceMappingURL=index.js.map