DEV Community: Ali Gürtuna | AGProLabs

A 403 error page is not a noindex audit of the original page

Ali Gürtuna | AGProLabs — Fri, 16 Oct 2026 09:37:06 +0000

A response inspector can make a subtle evidence mistake: it finds a robots tag on a block page, then labels the intended source page as noindex. The tag was observed, but on the wrong kind of response.

Keep two fields separate: what the request returned and what that response establishes about the intended page. A 403 observation deserves its own record. It does not establish that the publisher added a noindex rule to the original page.

Here is a small, dependency-free Node.js classification function. It makes no requests and does not retry a blocked response.

The contract

Inspect the HTTP status before interpreting HTML robots rules.
Leave source directives unresolved for failed requests, known challenges and responses outside this example's HTML scope.
Pass only directives already resolved as applicable to the crawler being assessed. This function does not parse HTML, choose a user agent or resolve scoped X-Robots-Tag headers.
Call the successful result no_noindex_observed, never indexed or SEO passed.

Save this as response-evidence.cjs:

function classifyHtmlObservation({ status, contentType = '', challenge = false, applicableDirectives = [] }) {
  if (!Number.isInteger(status) || status < 100 || status > 599)
    return { kind: 'invalid_status', sourceDirectives: null };
  if (status !== 200)
    return { kind: 'http_observation', status, sourceDirectives: null };
  if (challenge)
    return { kind: 'challenge_unverified', status, sourceDirectives: null };
  if (!/^(text\/html|application\/xhtml\+xml)(?:;|$)/i.test(contentType.trim()))
    return { kind: 'outside_html_scope', status, sourceDirectives: null };
  if (!Array.isArray(applicableDirectives) || applicableDirectives.some(x => typeof x !== 'string'))
    throw new TypeError('Resolve applicable directives to an array of strings first');
  const tokens = [...new Set(applicableDirectives.flatMap(x => x.toLowerCase().split(/[,\s]+/)).filter(Boolean))];
  return {
    kind: tokens.some(x => x === 'noindex' || x === 'none') ? 'noindex_observed' : 'no_noindex_observed',
    status,
    sourceDirectives: tokens
  };
}
module.exports = { classifyHtmlObservation };

Run the boundary cases

Save this beside it as response-evidence.test.cjs, then run node response-evidence.test.cjs:

const assert = require('node:assert/strict');
const { classifyHtmlObservation: check } = require('./response-evidence.cjs');
const base = { status: 200, contentType: 'text/html; charset=utf-8' };
const cases = [
  [{ ...base, status: 403, applicableDirectives: ['noindex'] }, 'http_observation'],
  [{ ...base, status: 429, applicableDirectives: ['noindex'] }, 'http_observation'],
  [{ ...base, challenge: true, applicableDirectives: ['noindex'] }, 'challenge_unverified'],
  [{ ...base, status: '200' }, 'invalid_status'],
  [{ ...base, contentType: 'application/pdf' }, 'outside_html_scope'],
  [{ ...base, applicableDirectives: ['NOINDEX, follow'] }, 'noindex_observed'],
  [{ ...base, applicableDirectives: ['none'] }, 'noindex_observed'],
  [{ ...base, applicableDirectives: ['noimageindex'] }, 'no_noindex_observed'],
  [{ ...base, applicableDirectives: [] }, 'no_noindex_observed'],
  [{ ...base, contentType: 'application/xhtml+xml', applicableDirectives: ['index'] }, 'no_noindex_observed']
];
for (const [input, kind] of cases) assert.equal(check(input).kind, kind);
for (const [input] of cases.slice(0, 5)) assert.equal(check(input).sourceDirectives, null);
const input = { ...base, applicableDirectives: ['index, follow', 'follow'] };
const before = JSON.stringify(input), out = check(input);
assert.deepEqual(out.sourceDirectives, ['index', 'follow']);
out.sourceDirectives.push('changed');
assert.equal(JSON.stringify(input), before);
assert.throws(() => check({ ...base, applicableDirectives: [null] }), TypeError);
console.log('PASS: 10 response classes, unresolved directives on five blocked/out-of-scope cases, deduplication, input preservation and type validation');

The fixtures cover ten response classes, including a 403 body containing noindex, a successful challenge page, the none directive, and noimageindex. They also check that the caller's input is preserved and the returned token array is independent.

What the result does not prove

Absence of an observed noindex rule is only one finding. This helper does not check robots.txt access, canonical selection, soft errors, rendered content, crawler-specific responses or actual search-index status. Preserve the response timestamp and final URL in the surrounding request record; redirects need separate treatment. A known challenge remains unresolved even when its HTTP status is 200.

Google documents both page-level robots directives and HTTP status handling. A successful response does not guarantee indexing.

I build AGProLabs. This is an engineering note about evidence labels, not a claim about search visibility or trading results. AI-assisted article and code; the included fixtures were executed locally.

Do not guess which CSV column contains the URL

Ali Gürtuna | AGProLabs — Fri, 16 Oct 2026 08:30:59 +0000

A resource importer can parse a CSV successfully and still read the wrong column. If the file changes from url,title to title,url, a hard-coded row[0] silently turns a display title into a destination.

Here is a small contract for a two-column application format. It accepts either column order, trims header whitespace (including a leading BOM), and requires the exact, case-sensitive names url and title. Unknown, duplicate, missing and extra columns fail before processing any data rows.

export function columns(header) {
  if (!Array.isArray(header) || header.length !== 2) {
    throw new TypeError("Expected exactly two header cells");
  }
  const names = header.map(cell => {
    if (typeof cell !== "string") {
      throw new TypeError("Header cells must be strings");
    }
    return cell.trim();
  });
  if (new Set(names).size !== 2 ||
      !names.includes("url") || !names.includes("title")) {
    throw new TypeError("Expected unique url and title columns");
  }
  return { url: names.indexOf("url"), title: names.indexOf("title") };
}

Pass this function the header after a CSV parser has produced cells. Do not use split(","): quoted fields can contain commas and line breaks, as described in RFC 4180, section 2. Trimming header cells is this application's explicit policy; it is not a general CSV rule, and it must not trim every data value.

Save the function as columns.mjs and this check as columns.test.mjs, then run node columns.test.mjs:

import assert from "node:assert/strict";
import { columns } from "./columns.mjs";

assert.deepEqual(columns(["url", "title"]), { url: 0, title: 1 });
assert.deepEqual(columns(["title", "url"]), { url: 1, title: 0 });
assert.deepEqual(columns(["\uFEFFurl ", " title"]), { url: 0, title: 1 });
for (const header of [
  ["url", "url"], ["url", "name"], ["URL", "title"],
  ["url"], ["url", "title", "note"], ["url", null],
  "url,title", ["ｕｒｌ", "title"]
]) assert.throws(() => columns(header), TypeError);

const header = Object.freeze(["title", "url"]);
const index = columns(header);
const row = ["A title, with a comma", "https://example.com/item/"];
assert.equal(row[index.url], "https://example.com/item/");
assert.equal(row[index.title], "A title, with a comma");
assert.deepEqual(header, ["title", "url"]);
console.log("11 header cases and row mapping/non-mutation checks passed");

The last example deliberately contains a comma in the title. The already-parsed row remains intact, while the validated mapping selects its URL correctly. There are no network requests, writes or changes to the input header.

Boundary: a valid header does not prove that a destination is safe, reachable or appropriate to import. Validate row length, URL schemes, field limits and destination policy separately. If your format needs more columns, version that schema explicitly rather than guessing aliases.

Project context: I build AGProLabs. This is a standalone teaching example, not a claim that a production importer uses this implementation.

AI disclosure: this note and its code were generated with AI assistance. The included local checks were executed; no production integration or browser test is claimed.

A clickable control and an anchor are different audit records

Ali Gürtuna | AGProLabs — Fri, 16 Oct 2026 05:39:12 +0000

A resource menu can respond to a click while exposing no anchor destination. Record the element and its actual href before counting it as a web-address reference.

This small classifier operates on DOM attributes. It does not click anything or make requests:

function inspectTarget(tagName, href, base) {
  if (tagName !== 'A') return { kind: 'non-anchor-control' };
  if (href === null) return { kind: 'missing-href' };
  if (href.trim() === '') return { kind: 'empty-href' };
  try {
    const url = new URL(href, base);
    if (!['http:', 'https:'].includes(url.protocol)) {
      return { kind: 'non-web-scheme', scheme: url.protocol };
    }
    return { kind: 'web-address', href: url.href };
  } catch {
    return { kind: 'invalid-url' };
  }
}

const scope = document.querySelector('.resource-menu');
const audit = scope ? [...scope.querySelectorAll('a, button, [role="link"]')]
  .map(el => inspectTarget(el.tagName, el.getAttribute('href'), document.baseURI)) : [];

A button or a span with role="link" remains a non-anchor control. That may be correct for an action; a resource-navigation card should expose an appropriate destination. mailto: is a valid navigation scheme, but it is outside this example's HTTP/HTTPS inventory. An empty href is recorded separately rather than silently counted as a new resource.

JavaScript-inserted <a href> elements are still anchors. Google's crawlable-link guidance makes this distinction; “dynamic” alone is not a reason to reject a link.

Eleven local pure-function fixtures passed: button, span, missing/empty/blank href, malformed URL, relative URL, same-page fragment, absolute HTTPS, mailto and JavaScript scheme. The relative-URL fixture retains its query string and fragment after resolution. This does not test a browser adapter, fetch a destination, validate security, inspect robots/canonical settings, or prove crawling/indexing. A same-page fragment also does not establish a second content page.

Author context: I build AGProLabs. This original note was prepared with AI assistance; the fixture check is local evidence for the classifier only.

Keep an import receipt beside the file fingerprint

Ali Gürtuna | AGProLabs — Fri, 16 Oct 2026 00:18:00 +0000

A publishing tool can accept an import while its public output still needs checking. Keep a file fingerprint beside the acceptance receipt so the same file leads back to verification.

async function inspectImportFile(file, receipts) {
  if (!(file instanceof Blob) || !(receipts instanceof Map)) {
    throw new TypeError("Expected a Blob and a receipt Map");
  }
  if (file.size > 2 * 1024 * 1024) {
    throw new RangeError("This helper accepts files up to 2 MiB");
  }
  const bytes = await file.arrayBuffer();
  const digest = await crypto.subtle.digest("SHA-256", bytes);
  const key = Array.from(new Uint8Array(digest), byte =>
    byte.toString(16).padStart(2, "0")
  ).join("");
  return {
    key,
    next: receipts.get(key)?.status === "accepted"
      ? "verify-existing"
      : "reconcile-before-import"
  };
}

Record accepted only after an explicit success response. An absent or unknown receipt calls for reconciliation before another submission. This helper performs no upload and provides no server-side idempotency guarantee.

Three useful checks: identical bytes plus an accepted receipt return verify-existing; unknown receipts return reconcile-before-import; changed line endings require a new reconciliation. File fingerprints identify bytes. Continue deduplicating record destinations separately.

Web Crypto digest documentation explains the secure-context requirement and whole-input memory behavior. This helper limits files to 2 MiB. Six Node checks passed for the branches above, oversize files and invalid input; browser execution was not tested. Validate the import format separately.

I maintain the following example resource catalogs; the snippet is a standalone utility:

AI-generated original code and writing; six Node behavior checks passed. Source links lead to projects I maintain.

A resource-card link should name its destination

Ali Gürtuna | AGProLabs — Mon, 12 Oct 2026 23:12:47 +0000

A resource card can look polished while every link says “Open”. Give each destination a useful visible label before adding decoration.

MDN’s anchor reference explains that an anchor with href creates a hyperlink and its content should identify the destination.

<ul>
  <li><a href="https://example.com/tools/">Analysis tools directory</a></li>
  <li><a href="https://example.com/health/">Health topic archive</a></li>
  <li><a href="https://example.com/poets/">Poets directory</a></li>
</ul>

Quick manual check:

Read the link labels without the surrounding paragraphs.
Tab to each link and activate it with Enter.
Compare the destination page with what its label promised.

A label review alone does not certify accessibility, medical accuracy or the quality of an analysis tool. Check those separately.

I maintain AGProLabs, including Crypto Setup Planner. The same navigation question applies to my health categories directory and family poets directory: can a reader tell what opens?

AI-assisted educational note; the image illustrates my project, not a claim that this sample markup is deployed there. The code uses placeholder destinations.

Six concrete destination-label pairs

Here are six pages from projects I maintain, used as owner-disclosed examples for the label review. Read the labels on their own, then check the destination. The HTML sample above remains a placeholder example; this list is not an accessibility certification.

Page type	Visible label example	What the label clarifies
Stock guide	Global-stock currency and session guide	The reader expects an instrument-context explanation, not an order.
Gold guide	Gold: spot, futures and ETF guide	The label makes the instrument distinction visible.
Calculator	Daily calorie calculator: inputs and limitations	A calculation page should not be labelled as a personal recommendation.
Calculator	BMI calculator: height, weight and units	The label identifies the tool and its measurement inputs.
Author archive	Yahya Kemal author archive	An author archive is not the text of a particular poem.
Author archive	Tevfik Fikret author archive	Name the author when two cards share the same page type.

If a card has several destinations of the same type, keep the author, instrument or tool name in the visible link text. This resource-example update was prepared with AI assistance. No trading, diagnostic or treatment instruction is implied.

Distinguish the page type, not just the subject

A reader can recognise a familiar topic and still open the wrong kind of page. For a resource card, keep the destination type in its label. These five pairs come from projects I maintain; they illustrate navigation choices rather than independent endorsements.

Reader question	First destination	Different destination	Label distinction
What is this tool, and how is it activated?	Dynamic Channels Elite product and access details	TradingView activation instructions	Product scope and access instructions answer different questions.
Which workflow am I comparing, and what should I check before buying?	Crypto Setup Planner and Trading Suite comparison	Technical-analysis tool buying checklist	A comparison names alternatives; a checklist names review steps.
What context am I measuring, and what is my review sequence?	Market breadth and watchlist context	Pre-market stock screening checklist	An explanation and an operational checklist need different labels.
How does this calculation work, and what does the publisher cover?	Basal metabolism calculator explanation	Medical-content scope and limitations	Tool methodology and publishing boundaries are separate destinations.
Am I browsing an author or reading about a work?	Birhan Keskin author archive	Literary-work reviews archive	An author archive and a work-review archive are different page types.

For implementation, use the visible label as the accessible name when it already describes the destination. Do not replace it with a generic “Open” label. Recheck the label after a destination changes. These examples do not certify the sites’ accessibility or provide personal trading or health advice.

Review similar labels as pairs

A useful final check is to put two plausible destinations side by side. Would someone reading a screen-reader link list know which one to activate? These four examples use pages from projects I maintain.

Label one	Label two	Detail to keep visible
Confirmed-candle and repainting explanation	Look-ahead bias and chart-replay review	A candle-confirmation explanation and a replay-bias review are different reading tasks.
Channel quality-score explanation	Channel follow-rate and sample-size explanation	A quality score and a follow-rate statistic should not share the generic label “Channel results”.
Daily water calculator: purpose and inputs	Health-calculator directory	Name the individual calculator; identify the directory as a place to browse tools.
Şaban Gürtuna author archive	Rüzgârlı Tepe book presentation	A writer’s archive and a named book presentation are separate destinations.

In a real component, check the rendered accessible name after adding an icon, a truncated title or an aria-label. Keep enough of the visible name to distinguish the destination. This manual exercise is not a complete accessibility audit. The original placeholder HTML is unchanged; the table is an AI-assisted, owner-disclosed resource example.

Do not render unavailable as zero: a unit-aware JavaScript metric formatter

Ali Gürtuna | AGProLabs — Mon, 12 Oct 2026 12:29:41 +0000

A blank card, an observed zero and a malformed number are three different states. Formatting all three as 0.00% may produce a tidy interface, but it removes information the reader needs.

I maintain AGProLabs, where chart-reading interfaces make this distinction useful. This post offers a small independent JavaScript display contract. It is not proprietary indicator source, a market-data feed, a clinical assessment or a financial calculation. All test values below are synthetic.

Start with a declared unit

Consider two inputs:

{ value: 0.25, unit: "share" } means a share between zero and one; the display should be 25.00%.
{ value: 25, unit: "percentage" } already uses percentage units; multiplying it again would be a display error.

The number alone cannot resolve that distinction. Give the producer a contract and reject unsupported units at the boundary. Here, share is deliberately restricted to [0, 1]. It is not a generic ratio or a percentage change. percentage permits negative values and values above 100 because this formatter does not know the domain meaning. A nonnegative count must be a safe integer.

Preserve the missing state

The producer sends either an observed record with a value and unit, or an unavailable record without a value. A missing record carrying value: 0 is contradictory and rejected. A numeric string is rejected instead of silently parsed. That makes schema drift visible to the calling component.

This is a rendering contract, not evidence validation. The word observed in a payload does not prove that an upstream source actually measured anything. Source identity, observation time, interval and authorization belong to separate checks.

The module

Save this as metric-display.mjs:

export function formatMetric(record, decimals = 2) {
  const bad = reason => ({ status: "invalid", text: "Invalid", reason });
  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 6)
    return bad("invalid precision");
  if (!record || typeof record !== "object" || Array.isArray(record))
    return bad("not a metric record");
  if (record.state === "unavailable") {
    return Object.hasOwn(record, "value")
      ? bad("unavailable record contains a value")
      : { status: "unavailable", text: "Unavailable" };
  }
  if (record.state !== "observed") return bad("unknown state");
  const { value, unit } = record;
  if (typeof value !== "number" || !Number.isFinite(value))
    return bad("not a finite number");
  if (!["percentage", "share", "count"].includes(unit))
    return bad("unknown unit");
  if (unit === "share" && (value < 0 || value > 1))
    return bad("share outside zero to one");
  if (unit === "count" && (!Number.isSafeInteger(value) || value < 0))
    return bad("not a nonnegative safe count");
  const displayed = unit === "share" ? value * 100 : value;
  const places = unit === "count" ? 0 : decimals;
  let text = displayed.toFixed(places);
  // A rounded negative zero must not appear as a negative change.
  if (Number(text) === 0) text = (0).toFixed(places);
  return { status: "ready", text: text + (unit === "count" ? "" : "%") };
}

The component receives a status as well as text. It can render unavailable and invalid values differently, while retaining the diagnostic reason in an appropriate developer-facing channel. Do not expose raw private payloads in a public error message.

The precision parameter is bounded to zero through six decimal places. Counts ignore fractional precision. A negative value rounded to zero is displayed as zero at the requested precision; that does not mean the original value was exactly zero. The example uses toFixed for a small deterministic contract, not a complete locale-aware financial display. Very large values may use exponential notation. If your interface needs currency, scientific units, localized grouping or exact decimal arithmetic, define and test those requirements separately.

Run the cases before connecting a UI

Save this next to the module as metric-display.test.mjs, then run node metric-display.test.mjs. The module uses Object.hasOwn and the test uses Node's built-in assertion module; use a runtime that supports those APIs.

import assert from "node:assert/strict";
import { formatMetric } from "./metric-display.mjs";
const observed = (value, unit) => ({ state: "observed", value, unit });
const cases = [
  ["observed zero stays zero", observed(0, "percentage"), "ready", "0.00%"],
  ["unavailable is not zero", { state: "unavailable" }, "unavailable", "Unavailable"],
  ["contradictory missing value", { state: "unavailable", value: 0 }, "invalid", "Invalid"],
  ["numeric string rejected", observed("25", "percentage"), "invalid", "Invalid"],
  ["infinity rejected", observed(Infinity, "percentage"), "invalid", "Invalid"],
  ["NaN rejected", observed(NaN, "percentage"), "invalid", "Invalid"],
  ["share conversion", observed(0.25, "share"), "ready", "25.00%"],
  ["percentage not converted again", observed(25, "percentage"), "ready", "25.00%"],
  ["share outside contract", observed(25, "share"), "invalid", "Invalid"],
  ["negative percentage preserved", observed(-12.5, "percentage"), "ready", "-12.50%"],
  ["integer count", observed(12, "count"), "ready", "12"],
  ["fractional count rejected", observed(1.5, "count"), "invalid", "Invalid"],
  ["negative count rejected", observed(-1, "count"), "invalid", "Invalid"],
  ["unsafe integer rejected", observed(Number.MAX_SAFE_INTEGER + 1, "count"), "invalid", "Invalid"],
  ["unknown unit rejected", observed(1, "price"), "invalid", "Invalid"],
  ["unknown state rejected", { state: "estimated", value: 1, unit: "count" }, "invalid", "Invalid"],
  ["rounded negative zero normalized", observed(-0.0001, "percentage"), "ready", "0.00%"],
  ["null record rejected", null, "invalid", "Invalid"]
];
for (const [name, record, status, text] of cases) {
  const result = formatMetric(record);
  assert.equal(result.status, status, name);
  assert.equal(result.text, text, name);
}
assert.equal(formatMetric(observed(1, "percentage"), 7).status, "invalid");
assert.equal(formatMetric(observed(1, "percentage"), -1).status, "invalid");
console.log(JSON.stringify({ passed: cases.length + 2, failed: 0 }));

Local result for this exact example: 20 passed, 0 failed. The first eighteen named cases cover the payloads and displayed text; two additional assertions cover invalid precision. That result applies to these synthetic cases. It is not a cross-browser test, an accessibility review, a performance benchmark or a guarantee about your live producer.

Decide what the component should retain

For a ready record, display the formatted value with its field label. For an unavailable record, preserve the missing state and offer an appropriate explanation. For an invalid record, avoid rendering a plausible substitute number. A UI test should confirm that the same states remain distinct after CSS and theme changes.

Retain the original unit in your observation record. In a journal, a label such as win fraction, percentage change or resolved-event count should not disappear when you copy a screenshot. A count is also not a denominator by itself: you need a separately identified sample to interpret a percentage.

Owner-maintained examples of the reading problem

These are resources from my own projects, provided as related context rather than independent endorsements:

Win rate versus expectancy provides a reading path for quantities that should not be treated as interchangeable.
Which series is being measured in a drawdown review? provides related context for keeping the measure and its reference together.
Gross assumptions versus costs is another reason to retain the calculation convention beside an output.
A screening journal template provides a place to document observation context before changing inputs.
AliGurtuna's calculation-tool directory is a separate owner-maintained resource. This formatter does not validate those tools, interpret a health result or provide clinical advice.

The practical rule is to keep the value, unit and availability separate until the display boundary. The caller still needs to establish what the value represents. A clean-looking zero should never be used to hide a missing or invalid record.

AI disclosure: prepared with AI assistance for the author's own projects. The example was executed locally with the tests shown. No private account, medical or live market data is used or collected. Educational software example only; no trading prediction, financial advice or guaranteed outcome.

Try the fixed examples in a browser

Open the independent Metric Display Lab. It offers eight synthetic records using the formatter above. Select a record, render it, and reset the page. Changing the selection clears the previous result.

The live Chrome check covered all eight fixtures, clearing between selections, and reset. The separate module still has its 20 local assertions shown above. These focused checks are not a full accessibility or cross-browser certification. No live market feed, analytics, local storage or personal input is involved. The lab is an independently designed educational example for the author’s own projects.

Check the source label before choosing a display unit

A producer still needs a field-specific mapping. These references from my own projects illustrate the reading questions to retain beside that mapping:

ATR percentage and its field meaning and Turnover thresholds and volume units: keep the field label and original unit with the observation.
Stale setup and observation age: a unit check does not establish whether a record is current.
In another domain, the BMI tool explanation and Waist-to-hip ratio tool explanation are separate source pages for reviewing input and method labels. They are not validated payloads for this formatter.

The synthetic module and its supported units remain unchanged. A field outside that contract needs a separate, tested mapping; a medical or financial interpretation does not belong in this display function. Owner-maintained, AI-assisted reference update.

Capture a review note without retaining its mutable input

Ali Gürtuna | AGProLabs — Mon, 12 Oct 2026 11:39:09 +0000

A saved review note should keep the values you captured, even if the editor's input object changes later. Appending the same mutable form object to a history array is a small shortcut with a large consequence: a later edit can silently rewrite the apparent past.

I maintain AGProLabs, AliGurtuna.com and Babamın Şiir Defteri. This is an independent educational JavaScript example for flat notes, not a production deployment, automatic publishing system or audit service.

Define the record before copying it

The narrow record contains five primitive fields: an ID, a label, a source URL, exact note text and an explicit epoch-millisecond observation time. Extra fields are deliberately excluded. A form may hold private drafts or nested UI state that do not belong in this record.

The text fields must be nonempty strings. The source link must use HTTPS without embedded username or password. Time must be a nonnegative safe integer within the representable Date range. Zero is valid; a numeric string is not. The function does not insert the current time or claim that a supplied time is truthful.

Save as observation-record.mjs:

export function captureObservation(input) {
  if (!input || typeof input !== 'object' || Array.isArray(input))
    throw new TypeError('A trusted flat input object is required');
  const { id, label, sourceUrl, notes, observedAtMs } = input;
  for (const value of [id, label, sourceUrl, notes]) {
    if (typeof value !== 'string' || !value.trim())
      throw new TypeError('Text fields must be nonempty strings');
  }
  const url = new URL(sourceUrl);
  if (url.protocol !== 'https:' || url.username || url.password)
    throw new TypeError('Use HTTPS source links without credentials');
  if (!Number.isSafeInteger(observedAtMs) || observedAtMs < 0 || observedAtMs > 8640000000000000)
    throw new TypeError('A nonnegative representable epoch-millisecond value is required');
  return Object.freeze({ id, label, sourceUrl: url.href, notes, observedAtMs });
}

The returned object is new, so later primitive assignments on the input cannot change it. Note wording is preserved, including surrounding whitespace; trimming is used only to reject blank fields. The URL uses the URL parser's serialization rather than an invented replacement expression.

Freeze only the contract you actually built

MDN's Object.freeze documentation describes shallow freezing. Freezing an object does not recursively freeze objects referenced by its properties. This example avoids that claim by permitting only primitive output fields. It is not a generic deep-copy function.

An HTTPS check is also not a privacy scrubber. HTTPS URLs can contain sensitive query values. Review any source URL before public use, apply an appropriate publication allowlist, and never treat this tiny validator as proof of public access or safe content. HTML rendering needs its own output handling. The function accepts trusted plain input; hostile getters and proxies are outside its boundary.

Eight focused scenarios

Save this beside the module as observation-record.test.mjs:

import test from 'node:test';
import assert from 'node:assert/strict';
import { captureObservation } from './observation-record.mjs';
const fixture = () => ({id:'synthetic-01',label:'Fixture reading',sourceUrl:'https://example.org/resource',notes:'Illustrative observation',observedAtMs:1000});

test('capture returns a separate flat record', () => {
  const input=fixture(),record=captureObservation(input);
  assert.notEqual(record,input);
  assert.deepEqual(record,input);
});
test('later input edits cannot rewrite captured primitive values', () => {
  const input=fixture(),record=captureObservation(input);
  input.notes='Later edit';input.observedAtMs=2000;
  assert.equal(record.notes,'Illustrative observation');
  assert.equal(record.observedAtMs,1000);
});
test('frozen output rejects direct edits in module strict mode', () => {
  const record=captureObservation(fixture());
  assert.ok(Object.isFrozen(record));
  assert.throws(()=>{record.notes='Rewrite';},TypeError);
});
test('unselected extra fields are excluded from output', () => {
  const record=captureObservation({...fixture(),privateDraft:'not for publication',nested:{x:1}});
  assert.equal(Object.hasOwn(record,'privateDraft'),false);
  assert.equal(Object.hasOwn(record,'nested'),false);
});
test('text field failures reject rather than stringify objects', () => {
  for(const field of ['id','label','sourceUrl','notes']) {
    assert.throws(()=>captureObservation({...fixture(),[field]:'   '}),TypeError);
    assert.throws(()=>captureObservation({...fixture(),[field]:{value:'text'}}),TypeError);
  }
});
test('unsafe source schemes and embedded credentials reject', () => {
  for(const sourceUrl of ['http://example.org','javascript:alert(1)','https://user:secret@example.org'])
    assert.throws(()=>captureObservation({...fixture(),sourceUrl}),TypeError);
});
test('time stays explicit, with zero valid and invalid numbers rejected', () => {
  assert.equal(captureObservation({...fixture(),observedAtMs:0}).observedAtMs,0);
  for(const observedAtMs of [-1,1.5,NaN,Infinity,'1000',8640000000000001])
    assert.throws(()=>captureObservation({...fixture(),observedAtMs}),TypeError);
});
test('capture preserves input and normalizes only the source URL', () => {
  const input=Object.freeze({...fixture(),sourceUrl:'https://example.org',notes:'  Keep exact wording  '});
  const record=captureObservation(input);
  assert.equal(input.sourceUrl,'https://example.org');
  assert.equal(record.sourceUrl,'https://example.org/');
  assert.equal(record.notes,'  Keep exact wording  ');
  assert.throws(()=>captureObservation(null),TypeError);
  assert.throws(()=>captureObservation([]),TypeError);
});

Run node --test observation-record.test.mjs. All eight local scenarios passed. The most useful regression case edits the original notes and time after capture, then checks that the captured fields stayed unchanged. Another case supplies private and nested extra fields and confirms that neither appears in the record. Direct assignment to the frozen result throws in module strict mode.

The tests cover this limited contract. They are not a throughput benchmark, an exhaustive security assessment or verification of any linked website's tools. The public repository includes the independent module and runner.

Preserve a record without overstating its meaning

For AGProLabs, a screened-candidate journal gives review notes their analytical context. The multi-timeframe guide and forward-testing guide explain different observation questions. Copying note text cannot establish source confirmation, market performance or a completed review.

In the author's calculator directory, health-category directory and awareness-resource directory, a saved reading note is still a software record. This example receives no clinical measurements and validates no medical tool or conclusion.

For poets and poems and literary reviews, preserving a note's text is different from establishing attribution, edition accuracy or permission to reproduce a work. Keep those checks separate.

The application work that remains

An in-memory frozen object is not durable history. Storage needs its own transactions, edit policy and versioning. Authentication, tamper evidence, approved publication fields, payload limits, source trust and concurrency need separate design. A user can create a replacement object; freeze is not a signature or access-control mechanism.

The modest result is useful: a flat captured note does not keep the mutable input object, and unselected properties do not leak into the returned record. The surrounding application must decide what may be captured, stored and published.

Disclosure: this article and its code were generated with AI assistance for the owner of the linked projects. Eight bounded tests were executed locally. No private Pine source, personal measurements, website code changes or automated search-engine submissions are included. Educational software only; financial and health links supply reading context, not advice.

A review cursor should not invent completion

Ali Gürtuna | AGProLabs — Mon, 12 Oct 2026 11:07:12 +0000

A resource list needs a way to resume without pretending that selection means completion. A numerical index can become confusing when the list changes order. A stable item ID gives the next review a clearer starting point, but it still needs a documented rule for missing IDs, excluded items and an exhausted candidate list.

I maintain AGProLabs, AliGurtuna.com and Babamın Şiir Defteri. Their resources include TradingView analysis guides, a health-tool directory and a poet directory. The example below is a standalone in-memory review selector for such a resource list. It is not an indexing API, automated publishing tool or deployed change to these projects.

A cursor is a position, not an outcome

Use three separate records:

A stable item identity supplied by your catalog.
A cursor identifying the item visited most recently.
Outcome or exclusion records with their own reasons and dates.

An item can be selected and never successfully reviewed. Persisting the cursor immediately after selection can skip an interrupted visit. Updating it after a completed visit still does not mean the resource was approved, published or indexed. Those outcomes need their own evidence.

This example calls its suggested cursor cursorAfterVisit to make that boundary visible. The function does not save it for you and does not manufacture a completion flag.

State the fallback rules

For this small contract, start just after the saved item in the current order. If it was removed, start at the first item. Wrap at most once. Skip ineligible items and explicitly excluded identities. Return null when no candidate remains under those rules.

A reorder preserves the cursor's identity but changes what comes after it. That is deliberate here. If your application needs a frozen traversal order across sessions, keep a catalog version or an explicit ordered queue as well. A stable ID alone does not freeze the list.

Save this as review-cursor.mjs:

export function nextReview(items, lastId = null, excluded = new Set()) {
  if (!Array.isArray(items) || !(excluded instanceof Set))
    throw new TypeError('items must be an array and excluded must be a Set');
  if (lastId !== null && (typeof lastId !== 'string' || !lastId.trim()))
    throw new TypeError('lastId must be null or a nonempty string');
  const seen = new Set();
  for (const item of items) {
    if (!item || typeof item.id !== 'string' || !item.id.trim() ||
        typeof item.eligible !== 'boolean' || seen.has(item.id))
      throw new TypeError('Each item needs a unique nonempty id and boolean eligible');
    seen.add(item.id);
  }
  if (!items.length) return null;
  const previous = items.findIndex(item => item.id === lastId);
  const start = previous < 0 ? 0 : (previous + 1) % items.length;
  for (let offset = 0; offset < items.length; offset++) {
    const item = items[(start + offset) % items.length];
    if (item.eligible && !excluded.has(item.id))
      return { item, cursorAfterVisit: item.id };
  }
  return null;
}

The selector validates identity uniqueness before choosing an item. Duplicate IDs should not quietly collapse into one review because you would lose the ability to say which entry was visited. Eligibility is a required boolean, not a truthy value such as "yes".

The returned item is the original object reference. The function does not mutate it, but it also does not deep-clone or freeze your catalog. Keep catalog mutation in your application's owning layer. The exclusion set is read-only from the selector's perspective; add a reviewed or temporarily held ID only under your stated policy.

Eight deterministic scenarios

Save as review-cursor.test.mjs beside the module:

import test from 'node:test';
import assert from 'node:assert/strict';
import { nextReview } from './review-cursor.mjs';
const items = ['a', 'b', 'c'].map(id => ({ id, eligible: true }));
test('first visit starts at the first eligible item', () => {
  assert.equal(nextReview(items).item.id, 'a');
});
test('cursor follows identity after a reorder', () => {
  assert.equal(nextReview([items[2], items[0], items[1]], 'a').item.id, 'b');
});
test('last item wraps once to the first', () => {
  assert.equal(nextReview(items, 'c').item.id, 'a');
});
test('eligibility and temporary exclusion are separate', () => {
  const input = [{ id: 'a', eligible: false }, items[1], items[2]];
  assert.equal(nextReview(input, null, new Set(['b'])).item.id, 'c');
});
test('no candidate does not manufacture a result', () => {
  assert.equal(nextReview([]), null);
  assert.equal(nextReview(items, null, new Set(['a','b','c'])), null);
});
test('a removed cursor uses the documented first-item fallback', () => {
  assert.equal(nextReview(items, 'removed').item.id, 'a');
});
test('invalid or duplicated identities fail explicitly', () => {
  assert.throws(() => nextReview([items[0], items[0]]), TypeError);
  assert.throws(() => nextReview([{ id: '', eligible: true }]), TypeError);
  assert.throws(() => nextReview([{ id: 'a', eligible: 'yes' }]), TypeError);
  assert.throws(() => nextReview({}, null), TypeError);
  assert.throws(() => nextReview(items, 2), TypeError);
  assert.throws(() => nextReview(items, null, []), TypeError);
});
test('selection does not mutate items, exclusions or completion state', () => {
  const input = Object.freeze(items.map(x => Object.freeze({ ...x })));
  const excluded = new Set(['b']);
  const result = nextReview(input, 'a', excluded);
  assert.equal(result.cursorAfterVisit, 'c');
  assert.deepEqual([...excluded], ['b']);
  assert.deepEqual(input, items);
  assert.equal(Object.hasOwn(result.item, 'completed'), false);
});

Run node --test review-cursor.test.mjs. The Node test-runner documentation explains the built-in runner. All eight scenarios passed in this article's local check. The fixtures cover initial selection, reordering, wrapping, eligibility, temporary exclusion, exhaustion, a removed cursor, invalid identities and non-mutation. The final count is eight test scenarios, not a benchmark or exhaustive proof about every catalog.

Keep the outcome vocabulary relevant to the resource

A screened-candidate journal and a weekly process review show why an observation and its later interpretation need separate records. A cursor can help select the next record to examine, but it cannot establish data quality, execution or trading performance.

For health categories or psychological-awareness resources, “visited” is a browsing status, not a medical conclusion. In the literary-review archive, opening a review does not mean you have read the original work or verified its attribution.

These are examples of different outcome vocabularies, not a reason to force every project into one approval state. Store the right outcome separately from the universal navigation position.

What a real application still needs

Persist the cursor and outcome records atomically where your storage requires it. Refresh the catalog under a clear version policy. Handle interrupted visits and unavailable resources without calling them successful. A live system may also need concurrency control, migrations, access checks and its own error handling; this pure selector supplies none of those automatically.

The useful result is modest: you can explain where review resumes, why an item was skipped and what a selected item does not prove. That makes a resource workflow easier to inspect without inflating its completion claims.

Disclosure: I maintain the linked projects. This article and code were prepared with AI assistance and locally tested. No production workflow, search-engine request or main-site code was changed. Trading and health references are resource context, not financial or clinical advice.

Try the browser fixtures

Open the Review Cursor Lab. It imports the same independent module and holds synthetic state only in memory. Choose a last-visited identity, then try default, reordered, excluded, exhausted and removed-ID fixtures. Observe the selection and effective cursor separately.

Five selected fixtures plus synthetic-visit advancement and reset were checked in Chrome. With market-journal saved, excluding health selects poetry-directory; the exhausted fixture shows NO CANDIDATE and disables the visit button. Reset restores the initial selection and clears the simulated visit history. The page never creates a completion flag or submits a request. Reloading discards state; durable storage, concurrency and catalog versioning remain separate application work.

Browse the module and reproducible tests. No live feed, analytics, account, clinical input or proprietary Pine source is included. These focused fixtures are not a cross-browser or exhaustive application certification.

A late response should not replace the newer view

Ali Gürtuna | AGProLabs — Mon, 12 Oct 2026 10:53:58 +0000

A slow result can be valid for the request that created it and still be wrong for the view that is now open. Picture a reader switching a market basket, a directory filter or an archive search while the previous read is still pending. If the older response arrives last, it should not replace the newer view.

I maintain AGProLabs, AliGurtuna.com and Babamın Şiir Defteri. Their public resources provide concrete examples of different browsing contexts: candidate screening, health-resource directories and poet archives. The example below is a standalone read-coordination contract, not a claim that it is deployed on those sites.

Make ownership of the view explicit

Every new load gets a generation number. A result may commit only when its generation still owns the view. Success and failure need the same check: a late error from a superseded read should not erase the newer success.

The interface has four states: pending, ready, failed and idle. “Superseded” is the outcome of the old load, not a failure state displayed to the current reader. An explicit invalidation moves the view to idle and prevents a later completion from committing.

This deliberately does not cancel the underlying work. It coordinates commits. Transport cancellation, timeouts and server-side ordering need their own policies. It is intended for replaceable read results, not payments, orders or other writes that must be preserved.

A framework-independent implementation

Save as latest-reader.mjs:

export function createLatestReader(read, commit) {
  if (typeof read !== 'function' || typeof commit !== 'function')
    throw new TypeError('read and commit must be functions');
  let generation = 0;
  return {
    async load(input) {
      const ticket = ++generation;
      commit({ kind: 'pending', input });
      let value;
      try { value = await read(input); }
      catch (error) {
        if (ticket !== generation) return { kind: 'superseded' };
        commit({ kind: 'failed', input, error });
        return { kind: 'failed' };
      }
      if (ticket !== generation) return { kind: 'superseded' };
      commit({ kind: 'ready', input, value });
      return { kind: 'committed' };
    },
    invalidate() {
      ++generation;
      commit({ kind: 'idle' });
    }
  };
}

commit is a synchronous view-state sink. Keep it short and avoid starting another load from inside it; schedule independent actions outside that callback. If your UI schedules the state application asynchronously, keep the generation check at that later commit boundary as well. This example assumes that the callback applies the state synchronously.

Only the read operation is inside the failure-catching block. A thrown render error should not be relabeled as a source-read failure and then passed back through the same broken renderer. Application code should handle rejected load promises for unexpected sink failures.

There is one reader per replaceable view. Two widgets that should load independently need separate readers; a shared generation would make one widget's load supersede the other.

Test ordering without a live network

These tests use controllable promises. They decide which read settles first, so they do not depend on timers or a real endpoint. Save as latest-reader.test.mjs beside the module:

import test from 'node:test';
import assert from 'node:assert/strict';
import { createLatestReader } from './latest-reader.mjs';

function deferred() {
  let resolve, reject;
  const promise = new Promise((ok, fail) => { resolve = ok; reject = fail; });
  return { promise, resolve, reject };
}
function harness() {
  const jobs = new Map();
  const states = [];
  const reader = createLatestReader(key => {
    const job = deferred(); jobs.set(key, job); return job.promise;
  }, state => states.push(state));
  return { jobs, states, reader };
}
test('late success cannot replace the newer result', async () => {
  const { jobs, states, reader } = harness();
  const older = reader.load('older'); const newer = reader.load('newer');
  jobs.get('newer').resolve(2); assert.deepEqual(await newer, { kind: 'committed' });
  jobs.get('older').resolve(1); assert.deepEqual(await older, { kind: 'superseded' });
  assert.deepEqual(states.map(s => [s.kind, s.input]),
    [['pending','older'], ['pending','newer'], ['ready','newer']]);
});
test('late failure cannot overwrite a newer success', async () => {
  const { jobs, states, reader } = harness();
  const older = reader.load('older'); const newer = reader.load('newer');
  jobs.get('newer').resolve(2); await newer;
  jobs.get('older').reject(new Error('old error')); await older;
  assert.equal(states.at(-1).kind, 'ready');
  assert.equal(states.filter(s => s.kind === 'failed').length, 0);
});
test('current failure preserves its actual error', async () => {
  const { jobs, states, reader } = harness(); const error = new Error('current');
  const result = reader.load('current'); jobs.get('current').reject(error);
  assert.deepEqual(await result, { kind: 'failed' });
  assert.equal(states.at(-1).error, error);
});
test('invalidation prevents a pending completion from committing', async () => {
  const { jobs, states, reader } = harness(); const result = reader.load('current');
  reader.invalidate(); jobs.get('current').resolve(1);
  assert.deepEqual(await result, { kind: 'superseded' });
  assert.deepEqual(states.at(-1), { kind: 'idle' });
});
test('synchronous read errors use the failure state', async () => {
  const states = []; const error = new Error('read');
  const reader = createLatestReader(() => { throw error; }, s => states.push(s));
  assert.deepEqual(await reader.load('x'), { kind: 'failed' });
  assert.equal(states.at(-1).error, error);
});
test('a render error is not relabeled as a read failure', async () => {
  const kinds = []; const error = new Error('render');
  const reader = createLatestReader(async () => 1, state => {
    kinds.push(state.kind); if (state.kind === 'ready') throw error;
  });
  await assert.rejects(reader.load('x'), e => e === error);
  assert.deepEqual(kinds, ['pending', 'ready']);
});
test('invalid dependencies fail before any load', () => {
  assert.throws(() => createLatestReader(null, () => {}), TypeError);
  assert.throws(() => createLatestReader(() => {}, null), TypeError);
});

Run node --test latest-reader.test.mjs. The Node test-runner documentation explains the built-in runner. In the local check for this article, all seven scenarios passed: late success, late failure, current failure, invalidation, synchronous read errors, renderer exceptions and invalid dependencies. These fixtures are not a browser benchmark or proof of every possible interaction.

Preserve meaning as well as ordering

A view should describe what its current result represents. For AGProLabs research, a shortlist-to-chart hand-off and a recorded journal observation are separate steps. Request ownership prevents one result from replacing another; it does not validate source freshness, analytical quality or a trading decision.

The same distinction matters for resource browsing. Health categories and psychological-awareness tools have different page roles. A successful read is not a medical diagnosis. In a literary-review archive, the returned review should match the current filter; that does not establish attribution or substitute for reading the original work.

What to add in a real application

Keep a clear loading state, a current error state and an explicit teardown/invalidation path. Add input validation, endpoint-specific caching and transport handling where appropriate. Avoid logging sensitive answers or tokens just to debug request order. A public tutorial can reproduce the race with synthetic keys and numbers.

The important boundary is small: the read may finish, but the result needs permission to commit to this view. Keeping that boundary explicit makes both the implementation and the tests easier to review.

Disclosure: I maintain the projects referenced here. This article and code were generated with AI assistance and locally tested. No production website or TradingView script was changed. The linked health and trading resources are context, not clinical or financial advice.

Parse the destination before deduplicating a resource link

Ali Gürtuna | AGProLabs — Mon, 12 Oct 2026 10:10:25 +0000

A useful project directory needs two separate answers: where will this link navigate, and what counts as the same resource? Treating those questions as one string-replacement operation creates subtle mistakes. A substring such as agprolabs.com can appear inside an unrelated hostname. Removing every query parameter can merge two different resources. Changing the destination while counting it can quietly alter what the reader opens.

I maintain AGProLabs, AliGurtuna.com and Babamın Şiir Defteri. Their resource pages include a TradingView review journal, a health-tool directory and a literary-review archive. These are distinct projects and readers. This example implements a small editorial URL policy for a resource menu across those three owned domains. It does not fetch pages or certify their content.

State the identity policy before writing the function

For this example:

Require an absolute HTTPS address. Do not infer a base URL or silently add a protocol.
Parse the URL, then compare the complete hostname against a set of three approved domains. Explicitly allow the www aliases.
Reject credentials and non-default ports. The parser normalizes the default HTTPS port.
Exclude selected administrative, account and private workflow paths.
Keep the parsed navigation address, including its query and fragment.
Build a separate reporting identity: strip www, ignore the fragment and remove only utm_ parameters. Sort the remaining query parameters.
Preserve path case and the trailing slash. Whether two such routes are equivalent needs site-specific evidence.

The www aliases and tracking-parameter equivalence are declared rules for this example, not universal canonicalization rules. A different website could route them differently. The MDN URL reference documents the parsed properties this function uses.

A small pure function

Save this as resource-link.mjs:

const domains = new Set([
  'agprolabs.com', 'aligurtuna.com', 'babaminsiirdefteri.com'
]);
const blocked = /^(?:wp-admin|wp-login\.php|wp-json|cart|checkout|my-account|quick-purchase|crypto-screener(?:\.php)?)(?:\/|$)/i;

export function resourceLink(raw) {
  if (typeof raw !== 'string' || !/^https:\/\//i.test(raw))
    return { ok: false, reason: 'absolute_https_required' };
  let url;
  try { url = new URL(raw); }
  catch { return { ok: false, reason: 'invalid_url' }; }
  if (url.username || url.password || url.port)
    return { ok: false, reason: 'credentials_or_port' };
  const domain = url.hostname.replace(/^www\./, '');
  if (!domains.has(domain)) return { ok: false, reason: 'unlisted_host' };
  let path;
  try { path = decodeURIComponent(url.pathname); }
  catch { return { ok: false, reason: 'invalid_encoding' }; }
  if (blocked.test(path.replace(/^\/+/, '')))
    return { ok: false, reason: 'excluded_path' };
  // Keep the navigable URL intact. Identity is a separate editorial policy.
  const identity = new URL(url.href);
  identity.hostname = domain;
  identity.hash = '';
  for (const name of [...identity.searchParams.keys()])
    if (/^utm_/i.test(name)) identity.searchParams.delete(name);
  identity.searchParams.sort();
  return { ok: true, href: url.href, identity: identity.href };
}

The result has an explicit rejection reason. A rejected row should stay in the editor with its reason visible; it should not be converted into a plausible-looking replacement link. For an accepted row, href is the parsed navigation address and identity is a reporting key. This keeps counting policy out of the reader's navigation path.

Use textContent when placing a user-supplied label in a DOM element. This function does not sanitize HTML labels. Likewise, do not treat an accepted origin as proof that a page returns HTTP 200, that its redirect destination remains approved, or that it is safe to fetch from a server. Those are separate validations. This is not an SSRF defense or a complete security boundary.

Test the cases that a substring check misses

Save the second file as resource-link.test.mjs. It uses Node's strict assertion module and imports the first file.

import assert from 'node:assert/strict';
import { resourceLink } from './resource-link.mjs';

const rejectCases = [
  [undefined, 'absolute_https_required'],
  ['/insights/', 'absolute_https_required'],
  ['http://agprolabs.com/', 'absolute_https_required'],
  ['javascript:alert(1)', 'absolute_https_required'],
  ['https://', 'invalid_url'],
  ['https://agprolabs.com.attacker.example/', 'unlisted_host'],
  ['https://attacker.example/?site=agprolabs.com', 'unlisted_host'],
  ['https://agprolabs.com@attacker.example/', 'credentials_or_port'],
  ['https://user:secret@agprolabs.com/', 'credentials_or_port'],
  ['https://agprolabs.com:8443/', 'credentials_or_port'],
  ['https://www.agprolabs.com/wp-admin/', 'excluded_path'],
  ['https://www.agprolabs.com/%77p-admin/', 'excluded_path'],
  ['https://www.agprolabs.com/insights/../checkout/', 'excluded_path'],
  ['https://www.agprolabs.com/crypto-screener.php', 'excluded_path'],
  ['https://www.aligurtuna.com/%ZZ', 'invalid_encoding'],
];
for (const [input, reason] of rejectCases)
  assert.deepEqual(resourceLink(input), { ok: false, reason });
let count = rejectCases.length;
for (const host of ['agprolabs.com', 'aligurtuna.com', 'babaminsiirdefteri.com']) {
  assert.equal(resourceLink(`https://${host}/`).ok, true); count++;
}
const original = 'https://www.agprolabs.com/insights/?utm_source=dev&b=2&a=1#notes';
assert.equal(resourceLink(original).href, original); count++;
assert.equal(resourceLink(original).identity, 'https://agprolabs.com/insights/?a=1&b=2'); count++;
assert.notEqual(resourceLink('https://agprolabs.com/?id=1').identity,
  resourceLink('https://agprolabs.com/?id=2').identity); count++;
assert.notEqual(resourceLink('https://agprolabs.com/guide').identity,
  resourceLink('https://agprolabs.com/guide/').identity); count++;
assert.equal(resourceLink('https://AGPROLABS.COM:443/').ok, true); count++;
assert.equal(resourceLink('https://www.agprolabs.com/insights/').identity,
  resourceLink('https://agprolabs.com/insights/').identity); count++;
assert.equal(resourceLink('https://agprolabs.com/?UTM_SOURCE=dev').identity,
  'https://agprolabs.com/'); count++;
console.log(JSON.stringify({ passed: count, failed: 0, scope: 'Pure URL-policy tests; no HTTP requests or security certification' }));

Run node resource-link.test.mjs in their shared folder. In the local check for this article, 25 assertions passed. They cover deceptive hostnames, credential-bearing addresses, a private screener route, malformed encoding, parsed dot segments, all three approved domains, retained meaningful query parameters and the deliberate trailing-slash distinction. This is evidence for these fixtures, not exhaustive proof about arbitrary URLs or live websites.

Keep the reader's purpose visible

A resource card needs more than a permitted address. Include a label that says what the destination provides and whether the article is maintained by the same author. For example, an AGProLabs card can lead to the Crypto Setup Planner product description or the candidate-to-chart review guide, depending on the question the card answers. Discovery methodology and a software purchase are different destinations.

In the health project, the psychological-awareness tools and health-category directory also serve different browsing tasks. A valid URL is not evidence of diagnostic accuracy. In the literature project, the poets and poems directory supports author-based navigation, while the linked review archive supports analytical reading. URL normalization should not invent literary attribution or merge different works.

Where the policy stops

Before publication, separately verify the actual destination, its intended public status and any redirect or canonical behavior. Keep the parsed navigation address and a record of the reason for rejection. Review the allowlist when a project adds a domain; do not make suffix matching progressively looser to get another row through.

The source-page × destination count can help audit a menu or publication log. It is not a count of independent referring domains, indexed backlinks or SEO authority. The same lesson applies across the three projects: an accepted input has a bounded meaning, and the interface should communicate that meaning clearly.

Disclosure: I maintain the projects linked in the examples. This article and code were prepared with AI assistance; the local fixture run is recorded separately. The health and trading references are product/resource context, not clinical or financial advice.

A manual destination-type fixture

An accepted URL does not tell the interface whether it opens documentation, an index or a specific work. For a small resource-menu review, keep that editorial type beside the label. The following owned-project pages are sample destinations, not outputs or additional test results from resourceLink.

Resource label	Editorial page type
WARMUP and missing-data documentation	Documentation
Confirmed-candle and repainting guide	Timing explanation
Indicator alert setup guide	Configuration guide
Analysis workspace guide	Workflow guide
TradingView script collections	Collection index
Tool buying checklist	Evaluation worksheet
Basal metabolic rate calculator explanation	Calculator explanation
Daily water-needs calculator explanation	Calculator explanation
Rüzgârlı Tepe book information	Book information
Şaban Gürtuna author archive	Author archive

Check the original page before assigning a type. A calculator explanation is not a personal result, and an author archive is not a particular poem. Keep this editorial field separate from both href and the reporting identity. It describes the intended reading task; it does not establish content accuracy or successful access.

Full feed coverage is not snapshot readiness: a tested JavaScript contract

Ali Gürtuna | AGProLabs — Mon, 12 Oct 2026 05:05:51 +0000

A dashboard can display every expected feed and still be unready for comparison. The distinction becomes visible when one source is developing, or when a cached observation belongs to the wrong completed interval.

A 4/4 badge answers a coverage question. It cannot establish that four observations satisfy the snapshot policy.

Declare the required slots first

This example uses two fictional instruments and two timeframes. Each required slot has a symbol, a timeframe and an expected completed close time. A caller provides that plan. The evaluator does not infer exchange sessions or decide which candle should be complete.

Daily and four-hour observations need not have equal close timestamps. They need to match their respective expected slots in the same declared plan. Comparing all timestamps for equality would reject legitimate multi-timeframe snapshots.

const daily = Date.parse("2026-10-11T00:00:00Z");
const fourHour = Date.parse("2026-10-11T20:00:00Z");
const plan = ["VENUE:A", "VENUE:B"].flatMap(symbol => [
  { symbol, timeframe: "D", expectedClose: daily },
  { symbol, timeframe: "4H", expectedClose: fourHour }
]);

These timestamps are synthetic fixtures, not an exchange calendar or live market observation.

Keep coverage, confirmation and alignment separate

The evaluator returns a reason along with the state. An unrelated row cannot replace a missing required slot, and a duplicate cannot increase coverage. Strict boolean confirmation avoids accepting a truthy string such as "false".

// Educational contract, synthetic inputs; not a production trading engine.
function assessSnapshot(plan, rows) {
  const waiting = reason => ({ state: 'WAIT', reason });
  const key = x => JSON.stringify([x.symbol, x.timeframe]);
  const validKey = x => x && typeof x.symbol === 'string' && x.symbol.trim()
    && typeof x.timeframe === 'string' && x.timeframe.trim();
  const validClose = x => Number.isSafeInteger(x) && x >= 0;
  if (!Array.isArray(plan) || !plan.length || !Array.isArray(rows)) {
    return waiting('INVALID_CONTRACT');
  }
  const expected = new Map();
  for (const slot of plan) {
    if (!validKey(slot) || !validClose(slot.expectedClose) || expected.has(key(slot))) {
      return waiting('INVALID_CONTRACT');
    }
    expected.set(key(slot), slot.expectedClose);
  }
  const observed = new Map();
  for (const row of rows) {
    if (!validKey(row)) return waiting('INVALID_ROW');
    const id = key(row);
    if (!expected.has(id)) continue; // unrelated data does not fill required slots
    if (observed.has(id)) return waiting('DUPLICATE_SLOT');
    observed.set(id, row);
  }
  const coverage = { present: observed.size, required: expected.size };
  if (observed.size !== expected.size) return { ...waiting('INCOMPLETE_COVERAGE'), coverage };
  for (const row of observed.values()) {
    if (row.confirmed !== true) return { ...waiting('UNCONFIRMED_SOURCE'), coverage };
  }
  for (const [id, row] of observed) {
    if (!validClose(row.closeTime)) return { ...waiting('INVALID_CLOSE_TIME'), coverage };
    if (row.closeTime !== expected.get(id)) {
      return { ...waiting('SNAPSHOT_MISMATCH'), coverage };
    }
  }
  return { state: 'REVIEW_READY', reason: 'CONTRACT_MET', coverage };
}

The order of checks is deliberate: validate the contract and identities; establish required coverage; check confirmation; then compare completed close slots. Only after those checks does the example produce REVIEW_READY. That label means the illustrative data contract passed. It does not mean a trading candidate qualified.

Reproduce the full-coverage failure

const rows = plan.map(p => ({
  symbol: p.symbol, timeframe: p.timeframe,
  closeTime: p.expectedClose, confirmed: true
}));

// One row belongs to an earlier four-hour slot.
rows[3].closeTime -= 4 * 3600000;
console.log(assessSnapshot(plan, rows));
// { state: "WAIT", reason: "SNAPSHOT_MISMATCH",
//   coverage: { present: 4, required: 4 } }

This is a useful UI boundary: keep the coverage badge and show the waiting reason beside it. Do not recolor the whole panel as ready merely because the count reached four.

Tests that exercise the boundary

13 local contract tests were run, including:

distinct Daily/4H close times satisfying one plan;
full coverage with a mismatched completed interval;
unconfirmed data and the string "true" instead of a boolean;
missing slots, duplicate observations and unrelated instruments;
empty plans, duplicated expected slots, invalid close values and null rows;
preservation of the input arrays.

All 13 passed for this small JavaScript function. That result does not validate an actual market feed, a paid indicator, exchange-session scheduling or browser performance.

Boundaries worth keeping explicit

The upstream producer must establish correct session calendars and expected closes. The row identity uses exact supplied identifiers; it does not normalize symbol aliases or resolve continuous-futures adjustments. Unknown extra instruments are ignored, but a malformed row fails explicitly. The returned reason is the first blocker encountered in the check sequence; a production diagnostic view may need a complete issue list.

This example has no price ranking, persistence threshold, liquidity model or order execution. A production system needs its own domain-specific gates, source provenance and failure handling.

Where the design question came from

The creator-owned Smart Swap and HOLD guide shows a real historical panel with complete coverage and pending time alignment. The confirmation-timing guide explains the separate clocks of chart and higher-timeframe sources. Both are useful interface examples; this function is an independent teaching exercise, not their internal implementation.

Disclosure: Trading Suite is an AGProLabs product. This article and illustrative code were prepared by an AI agent for AGProLabs; the contract was checked and the listed local tests were executed during preparation. These are creator-owned project references, not an independent review. The example is analytical education, not financial advice or a promise of results.

Two checks outside this snapshot contract

Required-slot coverage does not establish indicator warm-up. The warm-up and missing-data guide supplies domain context for separating an available observation from sufficient history. This example has no history-length input, so a passing result cannot establish that boundary.

Matching the caller-provided close slot also does not establish elapsed-time freshness. See the stale-setup guide for that separate review question. An outdated plan could still match outdated rows; production policy must establish the plan and review clock upstream.

These are additional creator-owned AGProLabs reading references. This AI-assisted note does not change the illustrative function or extend the scope of its earlier test results.

A dashboard metric needs units, provenance and a failure state

Ali Gürtuna | AGProLabs — Sun, 11 Oct 2026 20:01:17 +0000

A dashboard can display two valid numbers and still make an invalid comparison.

Consider three synthetic observations: 500 shares, 500 futures contracts and 500 tick events. They all fit in a JavaScript number. They do not measure the same thing.

The engineering problem starts when an adapter discards metadata and hands the UI only a numeric value. A formatter adds a compact suffix, a table sorts descending, and the screen makes unlike measurements look equivalent.

This article introduces a small comparison contract. It is a standalone educational JavaScript example, not the implementation of a TradingView script or a live market feed.

A metric is more than its number

Carry the measurement definition through the ingestion, validation and rendering layers:

Field	What the consumer needs to know
metric	What was measured: turnover, volume, count or something else
unit	Shares, contracts, quote currency, tick events, etc.
currency	The denomination, or an explicit non-applicable marker
interval	The aggregation window
session	The session coverage used by that observation
basisId	A trusted identifier for the measurement methodology
freshness	Whether a separate freshness policy has established currentness

The basis identifier matters. Two sources can both say “contracts” while referring to different contract specifications. Two providers can use the same display label for different aggregation methods. A label is necessary metadata; it is not evidence of equivalent semantics.

Your adapter should assign the basis from a reviewed source contract. Do not let arbitrary user input or an untrusted payload declare two methods equivalent.

Return a state before returning a difference

The UI needs to distinguish missing evidence from a valid difference. This function returns one of three states:

unavailable: a number, metadata or freshness evidence is missing or invalid;
incomparable: both records are populated, but their declared contracts differ;
comparable: the declared contract matches and a finite difference can be calculated.

function compareMetric(a, b) {
  const keys = [
    "metric", "unit", "currency", "interval", "session", "basisId"
  ];
  for (const x of [a, b]) {
    if (!x || typeof x.value !== "number" ||
        !Number.isFinite(x.value)) {
      return { state: "unavailable", reason: "invalid-number" };
    }
    if (keys.some(k => typeof x[k] !== "string" || !x[k].trim())) {
      return { state: "unavailable", reason: "missing-metadata" };
    }
    if (x.freshness !== "fresh") {
      return { state: "unavailable", reason: "freshness-not-established" };
    }
  }
  const different = keys.filter(k => a[k] !== b[k]);
  if (different.length) {
    return { state: "incomparable", fields: different };
  }
  const delta = a.value - b.value;
  return Number.isFinite(delta)
    ? { state: "comparable", delta }
    : { state: "unavailable", reason: "numeric-overflow" };
}

A real adapter must also enforce allowed metric/unit combinations and verify that the declared basis is trustworthy. This example deliberately does not fetch data, infer units or convert currencies.

Try a synthetic fixture

const baseline = {
  value: 100,
  metric: "turnover",
  unit: "quote-currency",
  currency: "USD",
  interval: "1h",
  session: "regular",
  basisId: "synthetic:quote-turnover-v1",
  freshness: "fresh"
};

compareMetric({ ...baseline, value: 120 }, baseline);
// { state: "comparable", delta: 20 }

compareMetric({ ...baseline, currency: "EUR" }, baseline);
// { state: "incomparable", fields: ["currency"] }

compareMetric({ ...baseline, freshness: "unknown" }, baseline);
// { state: "unavailable", reason: "freshness-not-established" }

The freshness flag is an input to this contract, not a freshness detector. Production code still needs an explicit timestamp, clock-skew tolerance, calendar/session policy and age threshold. Never substitute the browser's latest refresh time for the source observation time.

The isolated example passed 11 synthetic checks: a matching basis, different currency, different unit, different methodology, different interval, different session, unknown freshness, missing metadata, null value, non-finite value and subtraction overflow. Those checks do not validate a vendor feed or prove a production dashboard is correct.

Rendering rules that preserve meaning

When the state is unavailable, show a text reason rather than a fabricated zero. When it is incomparable, retain the original values and explain the differing fields. Do not calculate a ranking from the rejected comparison.

Keep the raw value and its provenance available for inspection. Format a copy for display; rounding should not silently rewrite the measurement used by the model. A cached record should retain its original source metadata and observation time.

A compatible contract establishes only this narrow arithmetic comparison. It does not establish liquidity, execution quality, investment suitability or predictive value.

Exercise the unit boundary in a working interface

The independent Volume Unit Workbook makes the input-side problem visible. It is a separate teaching model, not this comparison function and not the proprietary Planner engine.

Try three observations:

Load Base quantity: 1,000 declared units at 40 USD per unit produce an approximate 40,000 USD proxy. Load Quote amount: a declared 40,000 USD amount stays 40,000; multiplying it by price again would change the dimension.
Load Contracts, Tick activity or Unit unverified. An unknown contract specification remains unresolved, tick counts remain nonmonetary activity, and unverified units produce no estimate. No multiplier or monetary unit is guessed.
Load Another currency. The example retains 40,000 JPY and rejects comparison with the declared USD threshold. A matching number is not matching purchasing power. Then clear a quantity after calculating: the prior result disappears. An observed zero and an empty input remain separate states.

The repository source and tests include 20 bounded model tests for this worksheet. Eleven separate Chrome checks covered its six cases, zero, blank quantity, threshold equality, absent threshold and reset. These results do not validate real feeds, trusted metadata, a calendar policy, production runtime or the original comparison function in this article. The inputs are invented and remain in browser memory.

For the author-maintained reading context, the turnover and volume-unit guide explains why a declared quantity needs its instrument convention; the global stock currency and session guide explains why a basket also needs its currency and clock context. A reviewed source adapter must establish those facts before populating the comparison contract above.

Apply this to a market-review interface

Commodity feed selection provides a practical example: cash quotes, continuous futures, dated contracts and ETFs can need different source contracts. Our commodity screening guide explains the instrument and volume-unit checks from the user side. Our relative volume versus liquidity guide covers another common interpretation error.

Disclosure: I am the founder of AGProLabs. Crypto Setup Planner is our TradingView candidate-screening product; this article's JavaScript is a separate educational example, not its source code. The article and example were prepared with AI assistance. Trading involves risk; analytical outputs do not guarantee outcomes.

Four places to inspect a unit boundary

These author-maintained reading resources help frame a review question. They do not validate the JavaScript contract or provide a personal recommendation.

ATR-percent screening — keep a percentage distinct from a raw price distance.
Risk/reward after fees — retain the declared cost assumptions alongside a comparison.
BMI calculator — inspect the height and weight units before interpreting a result.
Growth-percentile calculator — read the age and measurement context on the destination page.